前后端分离的项目中在后端使用Spring Security与Keycloak用openid的方式集成

最新推荐文章于 2025-06-01 09:04:32 发布
最新推荐文章于 2025-06-01 09:04:32 发布
阅读量2.4k 收藏 32
点赞数 32
CC 4.0 BY-SA版权
分类专栏： 开发笔记 文章标签： spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/getKonwledge/article/details/124008059

Spring Security与Keycloak用openid的方式集成

因为项目的要求，第一次了解keycloak，之前也没接触过，所以只能摸着石头过河，一步一步的探索，中间踩了不少坑，这些坑值得总结一下，本人也是小白，如果有理解不对的地方，希望大神们多多指教。
顺便说一下，项目是前后端分离，这里先只介绍后端部分
(因为前端不会，嘻嘻)

安装keycloak

windows版本安装

先贴出官方下载地址：keycloak 官方下载地址.选择自己想要的版本。

我用的是postgres数据库，如果使用别的数据库，可以参考其他文章，这种安装文章网上有很多的。

  1. 先在keycloak-15.1.1\modules\system\layers\keycloak\org目录下创建名字为postgresql的文件夹，在postgresql文件夹下创建名字为main的文件夹，在main文件夹下创建名字为module.xml的文件，另外在将postgres的jar包贴到main文件夹下。
    module.xml：
<?xml version="1.0" encoding="UTF-8"?>
<module name="org.postgresql" xmlns="urn:jboss:module:1.5">
    <resources>
    	<!-- 注意修改path里的值为自己下载的jar包 -->
        <resource-root path="postgresql-42.3.3.jar"/>
    </resources>
    <dependencies>
        <module name="javax.api"/>
        <module name="javax.transaction.api"/>
        <module name="javax.servlet.api" optional="true"/>
    </dependencies>
</module>

postgres的jar包下载地址：jar包下载地址

  1. 需要修改的文件：\keycloak-15.1.1\standalone\configuration\standalone.xml
    直接贴上我的配置文件
<subsystem xmlns="urn:jboss:domain:datasources:6.0">
            <datasources>
            <!-- 这一部分为自己需要修改的配置，配置自己的数据库链接参数，为了安全需要，我就把我自己的参数先注释掉了 -->
               <datasource jndi-name="java:jboss/datasources/KeycloakDS" pool-name="KeycloakDS" enabled="true" use-java-context="true">
                    <connection-url>jdbc:postgresql://服务器地址:端口/数据库的名称</connection-url>
                    <!-- driver与下面配置的driver的name保持一致 -->
                    <driver>postgresql</driver>
                    <security>
                        <user-name>用户名</user-name>
                        <password>密码</password>
                    </security>
                    <pool>
                        <max-pool-size>100</max-pool-size>
                    </pool>
                </datasource>
				<datasource jndi-name="java:jboss/datasources/ExampleDS" pool-name="ExampleDS" enabled="true" use-java-context="true" statistics-enabled="${wildfly.datasources.statistics-enabled:${wildfly.statistics-enabled:false}}">
                    <connection-url>jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE</connection-url>
                    <driver>h2</driver>
                    <security>
                        <user-name>sa</user-name>
                        <password>sa</password>
                    </security>
                </datasource>
                <drivers>
                	<!-- 这里module的值要与前面自己创建的文件名保持一致 -->
					<driver name="postgresql" module="org.postgresql">
						<driver-class>org.postgresql.Driver</driver-class>
						<xa-datasource-class>org.postgresql.xa.PGXADataSource</xa-datasource-class>
					</driver>
					<driver name="h2" module="com.h2database.h2">
                        <xa-datasource-class>org.h2.jdbcx.JdbcDataSource</xa-datasource-class>
                    </driver>
                </drivers>
            </datasources>
        </subsystem>

如果想要修改端口号，修改下面的参数

    <socket-binding-group name="standard-sockets" default-interface="public" port-offset="${jboss.socket.binding.port-offset:0}">
        <socket-binding name="ajp" port="${jboss.ajp.port:8082}"/>
        <socket-binding name="http" port="${jboss.http.port:8081}"/>
        <!-- 更改端口号需要修改该值 -->
        <socket-binding name="https" port="${jboss.https.port:8083}"/>
        <socket-binding name="management-http" interface="management" port="${jboss.management.http.port:9991}"/>
        <socket-binding name="management-https" interface="management" port="${jboss.management.https.port:9993}"/>
        <socket-binding name="txn-recovery-environment" port="4712"/>
        <socket-binding name="txn-status-manager" port="4713"/>
        <outbound-socket-binding name="mail-smtp">
            <remote-destination host="${jboss.mail.server.host:localhost}" port="${jboss.mail.server.port:25}"/>
        </outbound-socket-binding>
    </socket-binding-group>

点击\keycloak-15.1.1\bin\standalone.bat启动keycloak，在浏览器输入端口号就可以进入到keycloak的登录界面

linux版本安装

我不是用docker的方式安装的，直接在网上在下tar包解压后，剩下的安装步骤就跟windows一样的了

Spring Security与Keycloak集成

keycloak的页面设置先跳过，直接附上后端代码部分

  1. maven依赖导入
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.keycloak</groupId>
            <artifactId>keycloak-spring-security-adapter</artifactId>
            <version>17.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.keycloak</groupId>
            <artifactId>keycloak-spring-boot-adapter-core</artifactId>
            <version>17.0.1</version>
        </dependency>
  1. 创建KeycloakSecurityConfig类，继承KeycloakWebSecurityConfigurerAdapter类。因为这个类比较重要，所以这里先说最重要的两个方法，configure(AuthenticationManagerBuilder auth)方法和configure(HttpSecurity http)方法
@Configuration
@EnableWebSecurity
@ComponentScan(basePackageClasses = KeycloakSecurityComponents.class)
public class KeycloakSecurityConfig extends KeycloakWebSecurityConfigurerAdapter {
	@Autowired
    private CustomizeAuthenticationEntryPoint authenticationEntryPoint;

    @Autowired
    private CustomizeAuthenticationFailureHandler authenticationFailureHandler;

    @Autowired
    private CustomizeAuthenticationSuccessHandler authenticationSuccessHandler;

    @Autowired
    private CustomizeLogoutSuccessHandler logoutSuccessHandler;

    @Autowired
    private CustomizeSessionInformationExpiredStrategy sessionInformationExpiredStrategy;

    @Autowired
    @Qualifier("userDetailsServiceImpl")
    public UserDetailsService userDetailsService;

    @Autowired
    public KeycloakClientRequestFactory keycloakClientRequestFactory;

    @Autowired
    private SecurityAuthenticationProvider securityAuthenticationProvider;

    /**
     * 自定义provider，提供用户认证的方式
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        SimpleAuthorityMapper mapper = new SimpleAuthorityMapper();
        mapper.setPrefix("ROLE_");
        SecurityAuthenticationProvider securityAuthenticationProvider = this.securityAuthenticationProvider;
        securityAuthenticationProvider.setGrantedAuthoritiesMapper(mapper);
        auth.authenticationProvider(securityAuthenticationProvider);
    }
 	@Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                // 配置资源访问权限
                .authorizeRequests()
                .antMatchers("/xxxxx").permitAll()
                .antMatchers("/private/**").hasRole(AuthorityEnum.ADMIN.getName())
                .antMatchers("/public/**").hasRole(AuthorityEnum.USER.getName())
                .anyRequest().authenticated()
                //配置异常处理
                .and()
                .exceptionHandling().authenticationEntryPoint(authenticationEntryPoint)
                //配置登录成功的处理
                .and()
                .formLogin().loginPage("/authentications/login").loginProcessingUrl("/private/login")
                .permitAll().successHandler(authenticationSuccessHandler).failureHandler(authenticationFailureHandler)
                //配置登出的处理
                .and()
                .logout().logoutUrl("/private/logout").logoutSuccessHandler(logoutSuccessHandler).clearAuthentication(true).deleteCookies("JSESSIONID")
                //配置过滤器
                .and()
                .addFilterBefore(keycloakAuthenticationProcessingFilter(), UsernamePasswordAuthenticationFilter.class)
                //配置单点登录的限制  允许同一个账号最多同时登录的数量
                .sessionManagement().maximumSessions(5).expiredSessionStrategy(sessionInformationExpiredStrategy);
        http.headers().cacheControl();
    }
}

需要说明的是：
在configure(AuthenticationManagerBuilder auth)方法里自定义的provider------SecurityAuthenticationProvider：Provider主要是提供认证，可以结合自己的业务需求写自己的认证逻辑，下面是我自己的provider

import com.vgc.price_index.mapper.AuthorityMapper;
import com.vgc.price_index.mapper.UserMapper;
import com.vgc.price_index.model.entity.User;
import lombok.extern.slf4j.Slf4j;
import org.keycloak.KeycloakPrincipal;
import org.keycloak.KeycloakSecurityContext;
import org.keycloak.adapters.springsecurity.account.KeycloakRole;
import org.keycloak.adapters.springsecurity.token.KeycloakAuthenticationToken;
import org.keycloak.representations.AccessToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.mapping.GrantedAuthoritiesMapper;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Slf4j
@Component
public class SecurityAuthenticationProvider implements AuthenticationProvider {

    private GrantedAuthoritiesMapper grantedAuthoritiesMapper;

    @Autowired
    //自己定义的mapper
    private UserMapper userMapper;

    @Autowired
    //自己定义的mapper
    private AuthorityMapper authorityMapper;

    public void setGrantedAuthoritiesMapper(GrantedAuthoritiesMapper grantedAuthoritiesMapper) {
        this.grantedAuthoritiesMapper = grantedAuthoritiesMapper;
    }

    /**
     * 验证Authentication，建立系统使用者信息principal(token)
     * 核心方法就是这个，通过token里的信息解析出登陆人的账号，然后在数据库里查询这个人有哪些权限
     */
    @Override
    public Authentication authenticate(Authentication authentication) throws RuntimeException {
        //从token中获取用户信息
        KeycloakAuthenticationToken token = (KeycloakAuthenticationToken) authentication;
        AccessToken accessToken = getAccessToken((token));
        String ntAccount = accessToken.getPreferredUsername();
        //查询用户是否存在，若不存在则存入数据库
        User user = userMapper.selectByNtaccount(ntAccount);
        if (null == user) return null;
        //根据userId查询本系统用户权限，放入token中
        List<String> authorities = authorityMapper.allPermissionByNtaccount(user.getNtaccount());
        List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
        for(String authority : authorities){
            KeycloakRole keycloakRole = new KeycloakRole(authority);
            grantedAuthorities.add(keycloakRole);
        }

        return new KeycloakAuthenticationToken(token.getAccount(), token.isInteractive(), mapAuthorities(grantedAuthorities));
    }

    private AccessToken getAccessToken(KeycloakAuthenticationToken principal) {
        KeycloakPrincipal keycloakPrincipal = (KeycloakPrincipal) principal.getPrincipal();
        KeycloakSecurityContext context = keycloakPrincipal.getKeycloakSecurityContext();
        return context.getToken();
    }

    private Collection<? extends GrantedAuthority> mapAuthorities(
            Collection<? extends GrantedAuthority> authorities) {
        return grantedAuthoritiesMapper != null
                ? grantedAuthoritiesMapper.mapAuthorities(authorities)
                : authorities;
    }

    @Override
    public boolean supports(Class<?> aClass) {
        return KeycloakAuthenticationToken.class.isAssignableFrom(aClass);
    }

}

在configure(HttpSecurity http)方法里的各种自定义的handler：
authenticationEntryPoint：异常处理的handler，出异常是调用此类
authenticationSuccessHandler：认证成功的处理
authenticationFailureHandler：认证失败的处理
logoutSuccessHandler：登出成功的处理
这些没有贴出代码的原因是，当集成了keycloak之后，keycloak会自己做处理，对应的类名为：
认证成功的处理：KeycloakAuthenticationSuccessHandler
认证失败的处理：KeycloakAuthenticationFailureHandler
异常的处理：KeycloakAuthenticationEntryPoint

关于config(HttpSecurity http）这个方法的配置，可以参考KeycloakWebSecurityConfigurerAdapter类里的配置

  1. 这个类里还有一个比较重要的bean：KeycloakConfigResolver，他的作用主要是解析keycloak的配置信息，并和token里的信息进行校验。这个有两种配置方式，根据官网的说法，一个是json方式，一个是直接在yml里配置。
    这里我选择了json的方式，因为在yml里读不到配置。
    /**
     * 读取keycloak的配置，keycloak_xxx.json
     */
    @Bean
    public KeycloakConfigResolver keycloakConfigResolver() {
        return new KeycloakConfigResolver() {
            private KeycloakDeployment keycloakDeployment;
            @Override
            public KeycloakDeployment resolve(HttpFacade.Request facade) {
                if (keycloakDeployment != null) {
                    return keycloakDeployment;
                }
                //keycloakConfigFilePath是json所在的目录
                String path = keycloakConfigFilePath;
                InputStream configInputStream = getClass().getResourceAsStream(path);

                if (configInputStream == null) {
                    throw new RuntimeException("Could not load Keycloak deployment info: " + path);
                } else {
                    keycloakDeployment = KeycloakDeploymentBuilder.build(configInputStream);
                }
                return keycloakDeployment;
            }
        };
    }

json配置如下：

{
  "realm": "xxx",
  "auth-server-url": "http://xxxx:port/auth",
  "ssl-required": "none",
  "resource": "xxx",
  "bearer-only": true,
  "credentials": {
    "secret": "xxx"
  }
}
  1. 还有一个值得说的是加入的过滤器：将这个过滤器加入到config中
    .and()
    .addFilterBefore(keycloakAuthenticationProcessingFilter(), UsernamePasswordAuthenticationFilter.class)
    /**
     * 将keycloak的过滤器加入到spring security中
     */
    @Bean
    public KeycloakAuthenticationProcessingFilter keycloakAuthenticationProcessingFilter() throws Exception {
        return new KeycloakAuthenticationProcessingFilter(authenticationManager());
    }
  1. 剩下的bean就是完全按着官网扒下来的, 最终这个类的代码如下

import org.keycloak.adapters.KeycloakConfigResolver;
import org.keycloak.adapters.KeycloakDeployment;
import org.keycloak.adapters.KeycloakDeploymentBuilder;
import org.keycloak.adapters.spi.HttpFacade;
import org.keycloak.adapters.springsecurity.KeycloakSecurityComponents;
import org.keycloak.adapters.springsecurity.client.KeycloakClientRequestFactory;
import org.keycloak.adapters.springsecurity.client.KeycloakRestTemplate;
import org.keycloak.adapters.springsecurity.config.KeycloakWebSecurityConfigurerAdapter;
import org.keycloak.adapters.springsecurity.filter.KeycloakAuthenticatedActionsFilter;
import org.keycloak.adapters.springsecurity.filter.KeycloakAuthenticationProcessingFilter;
import org.keycloak.adapters.springsecurity.filter.KeycloakPreAuthActionsFilter;
import org.keycloak.adapters.springsecurity.filter.KeycloakSecurityContextRequestFilter;
import org.keycloak.adapters.springsecurity.management.HttpSessionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.authority.mapping.SimpleAuthorityMapper;
import org.springframework.security.core.session.SessionRegistry;
import org.springframework.security.core.session.SessionRegistryImpl;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.authentication.session.NullAuthenticatedSessionStrategy;
import org.springframework.security.web.authentication.session.SessionAuthenticationStrategy;
import org.springframework.security.web.session.HttpSessionEventPublisher;

import java.io.InputStream;

@Configuration
@EnableWebSecurity
@ComponentScan(basePackageClasses = KeycloakSecurityComponents.class)
public class KeycloakSecurityConfig extends KeycloakWebSecurityConfigurerAdapter {

    @Autowired
    private CustomizeAuthenticationEntryPoint authenticationEntryPoint;

    @Autowired
    private CustomizeAuthenticationFailureHandler authenticationFailureHandler;

    @Autowired
    private CustomizeAuthenticationSuccessHandler authenticationSuccessHandler;

    @Autowired
    private CustomizeLogoutSuccessHandler logoutSuccessHandler;

    @Autowired
    private CustomizeSessionInformationExpiredStrategy sessionInformationExpiredStrategy;

    @Autowired
    @Qualifier("userDetailsServiceImpl")
    public UserDetailsService userDetailsService;

    @Autowired
    public KeycloakClientRequestFactory keycloakClientRequestFactory;

    @Autowired
    private SecurityAuthenticationProvider securityAuthenticationProvider;

    @Value("${keycloak.configFile}")
    private String keycloakConfigFilePath;

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public KeycloakRestTemplate keycloakRestTemplate() {
        return new KeycloakRestTemplate(keycloakClientRequestFactory);
    }

    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    /**
     * 自定义provider，提供用户认证的方式
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        SimpleAuthorityMapper mapper = new SimpleAuthorityMapper();
        mapper.setPrefix("ROLE_");
        SecurityAuthenticationProvider securityAuthenticationProvider = this.securityAuthenticationProvider;
        securityAuthenticationProvider.setGrantedAuthoritiesMapper(mapper);
        auth.authenticationProvider(securityAuthenticationProvider);
    }

    /**
     * 读取keycloak的配置，keycloak_xxx.json
     */
    @Bean
    public KeycloakConfigResolver keycloakConfigResolver() {
        return new KeycloakConfigResolver() {
            private KeycloakDeployment keycloakDeployment;
            @Override
            public KeycloakDeployment resolve(HttpFacade.Request facade) {
                if (keycloakDeployment != null) {
                    return keycloakDeployment;
                }
                String path = keycloakConfigFilePath;
                InputStream configInputStream = getClass().getResourceAsStream(path);

                if (configInputStream == null) {
                    throw new RuntimeException("Could not load Keycloak deployment info: " + path);
                } else {
                    keycloakDeployment = KeycloakDeploymentBuilder.build(configInputStream);
                }
                return keycloakDeployment;
            }
        };
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                // 配置资源访问权限
                .authorizeRequests()
                .antMatchers("xxx").permitAll()
                .antMatchers("/private/**").hasRole(AuthorityEnum.ADMIN.getName())
                .antMatchers("/public/**").hasRole(AuthorityEnum.USER.getName())
                .anyRequest().authenticated()
                //配置异常处理
                .and()
                .exceptionHandling().authenticationEntryPoint(authenticationEntryPoint)
                //配置登录成功的处理
                .and()
                .formLogin().loginPage("/authentications/login").loginProcessingUrl("/private/login")
                .permitAll().successHandler(authenticationSuccessHandler).failureHandler(authenticationFailureHandler)
                //配置登出的处理
                .and()
                .logout().logoutUrl("/private/logout").logoutSuccessHandler(logoutSuccessHandler).clearAuthentication(true).deleteCookies("JSESSIONID")
                //配置过滤器
                .and()
                .addFilterBefore(keycloakAuthenticationProcessingFilter(), UsernamePasswordAuthenticationFilter.class)
                //配置单点登录的限制  允许同一个账号最多同时登录的数量
                .sessionManagement().maximumSessions(5).expiredSessionStrategy(sessionInformationExpiredStrategy);
        http.headers().cacheControl();
    }

    @Bean
    @Override
    protected SessionAuthenticationStrategy sessionAuthenticationStrategy() {
        return new NullAuthenticatedSessionStrategy();
    }

    @Bean
    protected SessionRegistry buildSessionRegistry() {
        return new SessionRegistryImpl();
    }

    @Bean
    public FilterRegistrationBean keycloakAuthenticationProcessingFilterRegistrationBean(
            KeycloakAuthenticationProcessingFilter filter) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean(filter);
        registrationBean.setEnabled(false);
        return registrationBean;
    }

    @Bean
    public FilterRegistrationBean keycloakPreAuthActionsFilterRegistrationBean(
            KeycloakPreAuthActionsFilter filter) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean(filter);
        registrationBean.setEnabled(false);
        return registrationBean;
    }

    @Bean
    public FilterRegistrationBean keycloakAuthenticatedActionsFilterBean(
            KeycloakAuthenticatedActionsFilter filter) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean(filter);
        registrationBean.setEnabled(false);
        return registrationBean;
    }

    @Bean
    public FilterRegistrationBean keycloakSecurityContextRequestFilterBean(
            KeycloakSecurityContextRequestFilter filter) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean(filter);
        registrationBean.setEnabled(false);
        return registrationBean;
    }

    @Bean
    @Override
    @ConditionalOnMissingBean(HttpSessionManager.class)
    protected HttpSessionManager httpSessionManager() {
        return new HttpSessionManager();
    }

    @Bean
    public ServletListenerRegistrationBean<HttpSessionEventPublisher> httpSessionEventPublisher() {
        return new ServletListenerRegistrationBean<>(new HttpSessionEventPublisher());
    }

    /**
     * 将keycloak的过滤器加入到spring security中
     */
    @Bean
    public KeycloakAuthenticationProcessingFilter keycloakAuthenticationProcessingFilter() throws Exception {
        return new KeycloakAuthenticationProcessingFilter(authenticationManager());
    }
}

6.细节

  • 在header里放token时要加上前缀Bearer ，注意在Bearer后面有空格。
  • 自己定义的数据库角色名要加ROLE_前缀才可以和keycloak的角色匹配上
  • 剩下的等我想到了再补充吧。
最详细的Keycloak教程（建议收藏）：Keycloak实现手机号、验证码登陆——（三）基于springboot&keycloak+vue的前后端分离项目
mltaozi的博客
03-13 7343
本文将介绍如何使用Spring Boot、Keycloak和Vue构建一个具有前后端分离架构的Web应用程序。通过将前端与后端完全独立开发和部署，我们可以实现更高效的团队协作和灵活的技术选型。Spring Boot提供了一个稳定可靠的后台框架，Keycloak提供了身份验证和授权的解决方案，而Vue作为一种灵活易用的前端框架，使我们能够快速开发出优秀的用户界面。这样就实现了一个通过keycloak鉴权的简单前后端分离项目，当springboot版本太高（3.0）的话，也可以集成。
最详细的Keycloak教程（建议收藏）番外篇：SpringBoot集成Spring Security+Keycloak
mltaozi的博客
01-21 481
目前在springboot 3.x版本已经不支持keycloak适配器了，但是我们在集成的时候可以使用Spring Security+Keycloak来实现类似于老版本的keycloak适配器。上面的“oauth2ResourceServer”配置大家根据自己的具体业务需求来，roles名称是自己定义的，有些有role_前缀，有些没有。前面说到了怎么使用keycloak api去实现登录，1.下载keycloak，参考之前写的。编写IndexController。不废话，直接上代码了，具体实现。
keycloak18.0.0==前后端分离项目中使用，前端react后端springboot
hebian1994的博客
03-10 1447
这里，后端会从keycloak获取公钥并保存，然后用公钥来验证前端发来的token。新建两个client，一个用于前端，一个用于后端。新建一个realm,名字叫test1。在两个client下分别创建role。启动keycloak18。
Keycloak身份代理：OpenID Connect身份提供者配置指南
gitblog_00695的博客
06-01 308
Keycloak身份代理：OpenID Connect身份提供者配置指南 概述 在现代身份认证体系中，Keycloak作为开源的身份和访问管理解决方案，提供了强大的身份代理功能。本文将深入探讨如何在Keycloak中配置基于OpenID Connect v1.0协议的外部身份提供者(Identity Provider, IDP)，实现跨系统的统一身份认证。 OpenID Connect身份代理基础...
Spring Security 中使用Keycloak作为认证授权服务器
码农小胖哥
08-03 2562
Keycloak对流行的Java应用提供了适配器。在系列文章的上一篇我们演示了针对Spring Boot的安全保护，用的就是适配器的一种。Keycloak同样提供Spring Secur...
一个接口是如何在Keycloak和Spring Security之间执行的
码农小胖哥
08-18 961
在上一篇我们对Keycloak的常用配置进行了熟悉，今天我们来对Keycloak适配Spring Security的执行流程做一个分析，简单了解一下其定制的一些Spring Securit...
java web - springboot集成Keycloak + 前端开发环境
wdquan19851029的专栏
01-13 4243
这篇文章将会包括建立一个Keycloak server，springboot怎样连接Keycloak，以及怎样跟Spring Security搭配使用。 1.什么是Keycloak? Keycloak是一个面向现代应用和服务的开源的身份和访问管理解决方案。Keycloak提供了诸如单点登录(SSO)、身份代理和社交登录、用户联合、客户端适配器、管理控制台和帐户管理控制台等功能。想了解更多关于Keycloak的信息，请访问官方页面https://www.keycloak.org/。 本文将使用管理控制台
授权或身份认证管理系统，包含前后端，不需要集成，可以直接使用的完整项目
最新发布
07-15
我们正在寻找一个开源的、包含前后端的身份认证与权限管理系统，要求可以直接部署使用。根据用户需求，我们需要一个完整的解决方案，通常包括用户管理、角色管理、权限分配、登录认证等功能，并且前后端分离，便于...
探索Spring Security 5新OAuth2堆栈课程正式发布
在Spring Security OAuth项目中，Angular被用作客户端应用，表明了前后端分离架构的实践，其中前端应用通过安全的方式与后端服务进行交互。 通过了解以上知识点，读者不仅能够对Spring Security OAuth有一个基本的...
SpringCloud服务治理与最佳实践
kkchenjj的博客
07-13 923
通过上述步骤，我们不仅搭建了 Eureka 服务注册中心，还实现了服务实例的注册与心跳机制，以及服务发现的功能。这为构建高可用、可扩展的微服务架构提供了坚实的基础。在实际应用中，可以进一步配置 Eureka Server 和 Client，以满足更复杂的需求，如多数据中心、服务实例的元数据管理等。注意：虽然本教程遵循了您的要求，但在实际撰写技术文档时，通常会包含总结性陈述和基本原则的介绍，以帮助读者更好地理解和应用所学知识。路由规则可以通过。
Spring Boot 3 实现 SSO 单点登录的多种解决方案
nihao2q的博客
04-11 1447
登录成功后，认证中心签发 JWT（JSON Web Token）；子系统间共享公钥进行验证，避免中心化管理，系统无状态化。
OpenID教程　项目集成
04-17
项目集成要用到的，大家分享下．OpenID教程，我好不容易找到的．
keycloak18.0.0==前后端分离项目中使用，前端react后端springboot 源码
03-10
keycloak18.0.0==前后端分离项目中使用，前端react后端springboot。源码
keycloak24整合spring security oauth2
livemegoodboy的博客
05-27 1270
keycloak24整合spring security oauth2
Spring Boot中整合Keycloak OpenID Connect（OIDC）
canduecho的专栏
08-13 1587
这些步骤仅提供了一个基本的整合指南。确保在整合Keycloak OIDC时，参考Keycloak和Spring Boot的官方文档，以便获得更详细的信息和最佳实践。- 在Spring Boot的配置文件中，添加Keycloak相关的配置，包括Realm、Client ID、Client Secret等。- 在Keycloak管理员控制台中创建一个新的Realm，用于管理你的应用程序的身份验证和授权。- 在你的应用程序中，你可以使用Spring Security的注解来保护需要认证的资源。
系统集成做一个日志服务器,如何将简单的openid与我网站现有的日志系统集成？...
weixin_31975737的博客
08-11 248
我认为您最好的选择是使用Zend Framework中的OpenID模块。它可以单独使用，而不必使用整个框架，并且它们对如何使用它有一个相当简单的解释on their manual pages。这很简单(如果您理解OpenID的概念)：login_page.php：// Load the library Zend Framework way, or load it yourself...// Al...
微信小程序获取openid使用springsecurity和jwt实现权限验证过程和代码实现
weixin_35754676的博客
02-16 412
使用 Spring Security 和 JWT 来实现微信小程序获取 OpenID 的权限验证过程和代码实现，首先要定义一个用于获取 OpenID 的过滤器，然后实现该过滤器，在过滤器中调用微信小程序的接口获取用户的 OpenID，然后将 OpenID 存储到 JWT 中，最后将 JWT token 返回给前端。 ...
Spring Security和OpenID Connect
new_ord的博客
08-01 3468
OpenID Connect 是一个开放标准，由 OpenID 基金会于 2014 年 2 月发布。它定义了一种使用 OAuth 2.0 执行用户身份认证的互通方式。OpenID Connect 直接基于 OAuth 2.0 构建，并保持与它兼容。
Spring Boot 3.1 中如何整合Spring Security和Keycloak
芋艿V
06-06 897
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值