How to use

RealmAdapter

in

org.keycloak.models.cache.infinispan

@Override
public void invalidate() {
  invalidated = true;
  getDelegateForUpdate();
}

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

@Override
public IdentityProviderModel getIdentityProviderByAlias(String alias) {
  for (IdentityProviderModel identityProviderModel : getIdentityProviders()) {
    if (identityProviderModel.getAlias().equals(alias)) {
      return identityProviderModel;
    }
  }
  return null;
}

@Override
public ComponentModel importComponentModel(ComponentModel model) {
  getDelegateForUpdate();
  executeEvictions(model);
  return updated.importComponentModel(model);
}

@Override
public IdentityProviderModel getIdentityProviderByAlias(String alias) {
  if (isUpdated()) return updated.getIdentityProviderByAlias(alias);
  for (IdentityProviderModel identityProviderModel : getIdentityProviders()) {
    if (identityProviderModel.getAlias().equals(alias)) {
      return identityProviderModel;
    }
  }
  return null;
}

public void executeEvictions(ComponentModel model) {
  if (model == null) return;
  // If not realm component, check to see if it is a user storage provider child component (i.e. LDAP mapper)
  if (model.getParentId() != null && !model.getParentId().equals(getId())) {
    ComponentModel parent = getComponent(model.getParentId());
    if (parent != null && UserStorageProvider.class.getName().equals(parent.getProviderType())) {
      session.userCache().evict(this);
    }
    return;
  }
  // invalidate entire user cache if we're dealing with user storage SPI
  if (UserStorageProvider.class.getName().equals(model.getProviderType())) {
    session.userCache().evict(this);
  }
  // invalidate entire realm if we're dealing with client storage SPI
  // entire realm because of client roles, client lists, and clients
  if (ClientStorageProvider.class.getName().equals(model.getProviderType())) {
    cacheSession.evictRealmOnRemoval(this);
  }
}

@Override
public RealmModel getRealm(String id) {
  if (!cache.isEnabled()) return getDelegate().getRealm(id);
  CachedRealm cached = cache.getCachedRealm(id);
  if (cached == null) {
    RealmModel model = getDelegate().getRealm(id);
    if (model == null) return null;
    if (realmInvalidations.contains(id)) return model;
    cached = new CachedRealm(cache, this, model);
    cache.addCachedRealm(cached);
  } else if (realmInvalidations.contains(id)) {
    return getDelegate().getRealm(id);
  } else if (managedRealms.containsKey(id)) {
    return managedRealms.get(id);
  }
  RealmAdapter adapter = new RealmAdapter(cached, this);
  managedRealms.put(id, adapter);
  return adapter;
}

@Override
public AuthenticationFlowModel getFlowByAlias(String alias) {
  for (AuthenticationFlowModel flow : getAuthenticationFlows()) {
    if (flow.getAlias().equals(alias)) {
      return flow;
    }
  }
  return null;
}

@Override
public AuthenticatorConfigModel getAuthenticatorConfigByAlias(String alias) {
  for (AuthenticatorConfigModel config : getAuthenticatorConfigs()) {
    if (config.getAlias().equals(alias)) {
      return config;
    }
  }
  return null;
}

@Override
public X509Certificate getCertificate() {
  if (certificate != null) return certificate;
  certificate = KeycloakModelUtils.getCertificate(getCertificatePem());
  return certificate;
}

@Override
public Key getCodeSecretKey() {
  if (codeSecretKey == null) {
    codeSecretKey = KeycloakModelUtils.getSecretKey(getCodeSecret());
  }
  return codeSecretKey;
}

@Override
public ClientModel getClientByClientId(String clientId) {
  if (updated != null) return updated.getClientByClientId(clientId);
  String id = cached.getClients().get(clientId);
  if (id == null) return null;
  return getClientById(id);
}

@Override
public void updateComponent(ComponentModel component) {
  getDelegateForUpdate();
  executeEvictions(component);
  updated.updateComponent(component);
}

@Override
public RealmModel getRealmByName(String name) {
  if (!cache.isEnabled()) return getDelegate().getRealmByName(name);
  CachedRealm cached = cache.getCachedRealmByName(name);
  if (cached == null) {
    RealmModel model = getDelegate().getRealmByName(name);
    if (model == null) return null;
    if (realmInvalidations.contains(model.getId())) return model;
    cached = new CachedRealm(cache, this, model);
    cache.addCachedRealm(cached);
  } else if (realmInvalidations.contains(cached.getId())) {
    return getDelegate().getRealmByName(name);
  } else if (managedRealms.containsKey(cached.getId())) {
    return managedRealms.get(cached.getId());
  }
  RealmAdapter adapter = new RealmAdapter(cached, this);
  managedRealms.put(cached.getId(), adapter);
  return adapter;
}

@Override
public AuthenticationFlowModel getFlowByAlias(String alias) {
  for (AuthenticationFlowModel flow : getAuthenticationFlows()) {
    if (flow.getAlias().equals(alias)) {
      return flow;
    }
  }
  return null;
}

@Override
public AuthenticatorConfigModel getAuthenticatorConfigByAlias(String alias) {
  for (AuthenticatorConfigModel config : getAuthenticatorConfigs()) {
    if (config.getAlias().equals(alias)) {
      return config;
    }
  }
  return null;
}

@Override
public void setDisplayNameHtml(String displayNameHtml) {
  getDelegateForUpdate();
  updated.setDisplayNameHtml(displayNameHtml);
}

@Override
public ComponentModel addComponentModel(ComponentModel model) {
  getDelegateForUpdate();
  executeEvictions(model);
  return updated.addComponentModel(model);
}

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

  return managedRealms.get(id);
RealmAdapter adapter = new RealmAdapter(session, cached, this);
if (wasCached) {
  CachedRealmModel.RealmCachedEvent event = new CachedRealmModel.RealmCachedEvent() {