SpringCloud---SSO单点登录

最新推荐文章于 2024-06-21 15:43:09 发布
最新推荐文章于 2024-06-21 15:43:09 发布
阅读量2.2k 收藏 13
点赞数 4
分类专栏： SpringCloud 文章标签： java spring cloud spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LJ19971117/article/details/121913759
版权

文章目录

学习流程

服务设计

image-20211204122822832

创建sso父工程

  1. 添加父工程pom依赖
    • spring-cloud-alibaba-dependencies
    • spring-cloud-dependencies
    • spring-boot-dependencies

创建sso-system子工程

  用来写查询用户的业务,
  1. 添加子工程pom依赖
    • mysql-connector-java
    • mybatis-plus-boot-starter
    • spring-cloud-starter-alibaba-nacos-discovery
    • spring-cloud-starter-alibaba-nacos-config
    • spring-boot-starter-web
  2. 创建启动类, controller, service, pojo, dao(mapper), yml
  3. 配置yml(端口, 数据库, 服务注册/发现和配置)

创建sso-auth子工程

  1. 添加子工程pom文件

    • spring-boot-starter-web
    • spring-cloud-starter-alibaba-nacos-discovery
    • spring-cloud-starter-alibaba-nacos-config
    • spring-cloud-starter-openfeign
    • spring-cloud-starter-oauth2
      • Spring Security(提供登录页面) + JWT + OAUTH2

  2. 创建启动类, service, pojo, config, yml

  3. 配置yml文件(端口, 服务发现, 配置中心)

创建sso-resource子工程

  1. 添加pom依赖
  2. 创建启动类, controller, config, yml文件
  3. 配置yml(端口, 服务发现, 配置中心)

创建sso-gateway子工程

  1. 添加pom
  2. 创建启动类
  3. 创建yml

创建sso-ui前端业务子工程

  1. 添加pom
  2. 创建启动类
  3. resource下创建static目录
  4. static下创建HTML文件

数据库

  1. 用户表(ID username password)

image-20211204122837396

  1. 用户和角色关系表

image-20211204122855052

  1. 用户角色和菜单关系表

image-20211204122914104

  1. 用户菜单权限表

image-20211204122924065

表结构设计

image-20211204122932903

sql语句

通过用户ID查询到用户的权限

方案一: 单次查询
  1. 基于用户ID查询用户对应的角色ID (查询出的角色ID可能是多个)
select role_id
from tb_user_roles
where user_id = 1;
  1. 基于角色ID查询用户对象的菜单ID
select menu_id
from tb_role_menus
where role_id in (1);
  1. 基于菜单ID查询菜单权限标识
select permission
from tb_menus
where id in (1, 2, 3);
方案二: 嵌套查询
select permission
from tb_menus
where id in (select menu_id
from tb_role_menus
where role_id in (select role_id
from tb_user_roles
where user_id = 1));
方案三: 多表关联查询
select permission
from tb_user_roles ur
join tb_role_menus rm
on ur.role_id = rm.role_id
join tb_menus m
on rm.menu_id = m.id
where ur.user_id = 1;

SSO-system业务实现

概述

使用ssm实现用户和用户权限的查询, 并被auth远程调用

controller

UserController

@RestController
@CrossOrigin
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    /*基于用户名查询用户信息, 后续在sso-auth服务中会对这个方法进行远程调用*/

    @GetMapping("/login/{username}")
    public User doSelectUserByUsername(@PathVariable("username") String username) {
        return userService.selectUserByUsername(username);
    }

    /*基于用户ID查询用户权限, 后续会在sso-auth服务中会对这个方法进行远程调用*/
    @GetMapping("/permission/{userId}")
    public List<String> doSelectUserPermissions(@PathVariable("userId") Long userId) {
        return userService.selectUserPermissions(userId);
    }
}

service

UserService

public interface UserService {

    User selectUserByUsername(String username);

    List<String> selectUserPermissions(Long userId);
}

UserServiceImpl

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

    @Override
    public User selectUserByUsername(String username) {
        return userMapper.selectUserByUsername(username);
    }

    @Override
    public List<String> selectUserPermissions(Long userId) {
        // 方案一: 在这里可以调用数据层的单表查询方法, 查询三次获取用户信息
        // 方案二: 在这里可以调用数据层的多表嵌套或多表关联方式执行1次查询

        return userMapper.selectUserPermissions(userId);
    }
}

pojo

User

@Data
//@TableName(value = "tb-users")
public class User implements Serializable {

    private static final long serialVersionUID = 4831304712151465443L;
//    @TableId()
    private Long id;
    private String username;
    private String password;
    private String status;

}

dao

UserMapper

@Mapper //底层基于接口创建实现类
public interface UserMapper extends BaseMapper<User> {


    /**
     *基于用户名查询用户信息*/

    @Select("select id,username,password,status " +
            " from tb_users " +
            " where username = #{username} ")
    User selectUserByUsername(String username);

    /**基于用户名查询用户权限, 涉及到的表:
     * 1. tb_user_roles(用户角色关系表, 可以在此表中基于用户ID找到用户角色)
     * 2. tb_role_menus(用户菜单关系表, 可以基于角色ID找到菜单ID)
     * 3. tb_menus(菜单表, 菜单为资源的外在表现形式, 在此表中可以基于菜单ID找到权限标识
     * 基于如上三张表获取用户权限, 解决方案:
     * 1. 三次单表查询
     * 2. 嵌套查询
     * 3. 多表联查*/

    @Select("select distinct m.permission " +
            "from tb_user_roles ur join tb_role_menus rm on ur.role_id=rm.role_id" +
            "     join tb_menus m on rm.menu_id=m.id " +
            "where ur.user_id=#{userId}")
    List<String> selectUserPermissions(Long userId);
}
  • 注意yml配置

测试

  • 基于用户名查询用户信息

image-20211204122947578

  • 基于用户id（这里假设用户id为1）查询用户权限

image-20211204122956630

SSO-auth业务实现

概述一

先进行远程服务调用的实现,
调用system查询用户和用户权限的方法,
确认用户信息正确,
根据用户信息和签名生成令牌,
通过携带的令牌访问其他功能

pom依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--SSO技术方案:SpringSecurity+JWT+oauth2-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
        <!--open feign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

    </dependencies>

yml配置

server:
  port: 8071
spring:
  application:
    name: sso-auth
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848

启动类

  • 使用@EnableFeignClients注解进行远程调用
@EnableFeignClients
@SpringBootApplication
public class AuthApplication {

    public static void main(String[] args) {
        SpringApplication.run(AuthApplication.class, args);
    }
}

测试一

  1. 项目启动时，系统会默认生成一个登陆密码

image-20211204123009009

  1. 打开浏览器输入http://localhost:8071呈现登陆页面

image-20211204123018807

  1. 默认用户名为user, 执行登陆测试,登陆成功进入如下界面（因为没有定义登陆页面，所以会出现404）

image-20211204123027466

service

RemoteUserService接口

@FeignClient(value = "sso-system", contextId ="remoteUserService" )
public interface RemoteUserService {

    @GetMapping("/user/login/{username}")
    User selectUserByUsername( @PathVariable("username") String username);

    @GetMapping("/user/permission/{userId}")
    List<String> selectUserPermissions(@PathVariable("userId") Long userId);
}

UserDetailsServiceImpl实现类

@Slf4j
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private RemoteUserService remoteUserService;

    /**
     * 加载用户的用户名
     * 基于用户名获取数据库中的用户信息
     *
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //基于feign方式获取远程数据并封装
        //1.基于用户名获取用户信息
        com.jt.auth.pojo.User user = remoteUserService.selectUserByUsername(username);
        if(user==null) throw new UsernameNotFoundException("用户不存在");

        //2.基于用于id查询用户权限
        List<String> permissions = remoteUserService.selectUserPermissions(user.getId());
        log.debug("permissions {}",permissions.toString());

        //3.对查询结果进行封装并返回
        User userInfo = new User(username,
                user.getPassword(),
                AuthorityUtils.createAuthorityList(permissions.toArray(new String[]{})));

        return userInfo;
        //返回给认证中心,认证中心会基于用户输入的密码以及数据库的密码做一个比对
    }
}

pojo

@Data
public class User implements Serializable {

    private static final long serialVersionUID = 3570548663999909287L;
    private Long id;
    private String username;
    private String password;
    private String status;
}

config

SecurityConfig 配置类

package com.jt.auth.config;

import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

/**
 * 安全配置
 * 当我们在执行登录操作时,底层逻辑(了解):
 * 1)Filter(过滤器)
 * 2)AuthenticationManager (认证管理器)
 * 3)AuthenticationProvider(认证服务处理器)
 * 4)UserDetailsService(负责用户信息的获取及封装)
 *
 * @author 刘杰
 * @date 2021/11/02
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 初始化加密对象
     * 此对象提供了一种不可逆的加密方式,相对于md5方式会更加安全
     * 系统底层会基于此对象进行密码加密
     *
     * @return
     */
    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    /**
     * 定义认证管理器对象，这个对象负责完成用户信息的认证，
     * 即判定用户身份信息的合法性，在基于oauth2协议完成认
     * 证时，需要此对象，所以这里讲此对象拿出来交给spring管理
     *
     * 此对象要为后续oauth2的配置提供服务
     */
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManager();
    }

    /**
     * 配置配置认证规则
     * 假如在前后端分离架构中, 希望对登录成功和失败以后的信息以json形式返回,
     * 我们自己控制哪些URL需要认证, 哪些不需要认证, 可以重写下面的方法
     *
     * @param http http
     * @throws Exception 异常
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //super.configure(http);//默认所有请求都要认证
        //1.禁用跨域攻击(先这么写，不写会报403异常)  登录默认是post请求, 系统底层的跨域攻击设计不允许post请求
        http.csrf().disable();

        //2.放行所有资源的访问(后续可以基于选择对资源进行认证和放行)
//        http.authorizeRequests().mvcMatchers("/**").authenticated();
        http.authorizeRequests().anyRequest().permitAll(); //默认放行所有的
//        http.authorizeRequests().anyRequest().permitAll()
//                .mvcMatchers("/order/**").authenticated();

        //3.自定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin()                            //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                .failureHandler(failureHandler());
    }


    /**
     * @return
     */
//定义认证成功处理器
    //登录成功以后返回json数据
    @Bean
    public AuthenticationSuccessHandler successHandler(){

//        普通写法
//        return new AuthenticationSuccessHandler() {
//            @Override
//            public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
//
//            }
//        }
        //lambda   简写形式
        return (request,response,authentication)->{

            //构建map对象封装到要响应到客户端的数据
            Map<String,Object> map=new HashMap<>();
            map.put("state",200);
            map.put("message", "登陆成功");

            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }

    /**
     * Failure handler authentication failure handler.
     *
     * @return the authentication failure handler
     */
//定义登录失败处理器
    @Bean
    public AuthenticationFailureHandler failureHandler(){
        return (request,response,exception)->{

            //构建map对象封装到要响应到客户端的数据
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message", "登录失败");

            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }

    /**
     *
     *
     * @param response 响应
     * @param map
     * @throws IOException ioexception
     */
    private void writeJsonToClient(HttpServletResponse response, Map<String,Object> map) throws IOException {

        //将map对象,转换为json
        String json = new ObjectMapper().writeValueAsString(map);

        //设置响应数据的编码方式
        response.setCharacterEncoding("utf-8");

        //设置响应数据的类型
        response.setContentType("application/json;charset=utf-8");

        //将数据响应到客户端
        PrintWriter out = response.getWriter();
        out.println(json);
        out.flush();
    }
}

测试二

  1. 启动sso-system,sso-auth服务，然后基于postman访问网关,执行登录测试

image-20211204123041478

TokenConfig配置类

package com.jt.auth.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

/**
 * 构建令牌配置对象, 在微服务架构中, 登陆成功后, 可以将用户信息进行存储, 常用存储方式:
 * 1. 产生一个随机的字符串(token) 然后基于此字符串将用户信息存储到关系数据库(例如MySQL)
 * 2. 产生一个随机的字符串(token) 然后基于此字符串将用户信息存储到内存数据库(Redis)
 * 3. 基于jwt创建令牌(token), 在此令牌中存储用户信息, 这个令牌不需要写在数据库, 在客户端储存即可
 *
 * 基于如上设计方案, oauth2协议中给出了具体的api实现对象, 例如:
 * 配置令牌的存储策略,对于oauth2规范中提供了这样的几种策略
 * 1)JdbcTokenStore(这里是要将token存储到关系型数据库) (用的比较少)
 * 2)RedisTokenStore(这是要将token存储到redis数据库-key/value)
 * 3)JwtTokenStore(这里是将产生的token信息存储客户端，并且token中可以以自包含的形式存储一些用户信息)(对性能比较高的分布式架构)
 *
 * @author : 刘杰
 * @date : 2021/11/2 16:41
 */
@Configuration
public class TokenConfig {

    /**
     * 定义令牌存储方案, 本次选择基于jwt令牌方式存储用户状态
     * @return
     */
    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    /**
     * 配置jwt 令牌创建和解析对象
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(){
        JwtAccessTokenConverter Converter = new JwtAccessTokenConverter();
        Converter.setSigningKey("auth");
        return Converter;
    }

    //这里的签名key将来可以写到配置中心
    private static final String SIGNING_KEY = "auth";
}

Oauth2config

package com.jt.auth.config;

import com.jt.auth.service.UserDetailsServiceImpl;
import lombok.AllArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.PasswordEncoder;
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.token.AuthorizationServerTokenServices;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.http.HttpMethod;

import java.util.Arrays;

/**
 * @author : 刘杰
 * @date : 2021/11/2 17:01
 */
@AllArgsConstructor  // 全参构造
@EnableAuthorizationServer  // 启动认证和授权
@Configuration
public class Oauth2config extends AuthorizationServerConfigurerAdapter {

//    @Autowired
    private AuthenticationManager authenticationManager;
//    @Autowired
    private UserDetailsServiceImpl userDetailsService;
//    @Autowired
    private TokenStore tokenStore;
//    @Autowired
    private PasswordEncoder passwordEncoder;
//    @Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;


//    @Autowired
//    public Oauth2config(AuthenticationManager authenticationManager, UserDetailsServiceImpl userDetailsService, TokenStore tokenStore, PasswordEncoder passwordEncoder, JwtAccessTokenConverter jwtAccessTokenConverter) {
//        this.authenticationManager = authenticationManager;
//        this.userDetailsService = userDetailsService;
//        this.tokenStore = tokenStore;
//        this.passwordEncoder = passwordEncoder;
//        this.jwtAccessTokenConverter = jwtAccessTokenConverter;
//    }

    /**
     * 配置认证规则
     *
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        //super.configure(endpoints);
        endpoints
                //配置由谁完成认证(认证管理器)
                .authenticationManager(authenticationManager)
                //配置谁负责访问数据库(认证时需要两部分信息：一部分来自客户端，一部分来自数据库)
                .userDetailsService(userDetailsService)
                //配置进行认证的请求方式（默认支持post方式）
                .allowedTokenEndpointRequestMethods(HttpMethod.GET,HttpMethod.POST)
                //配置认证成功以后令牌生成和存储策略(默认令牌生成UUID.randomUUID(),存储方式为内存)
                .tokenServices(tokenService());

    }

    /**
     * 系统底层在完成认证以后会调用TokenService对象的相关方法
     * 获取TokenStore，基于tokenStore获取token对象
     * @return
     */
    @Bean
    public AuthorizationServerTokenServices tokenService(){

        //1.构建TokenService对象(此对象提供了创建，获取，刷新token的方法)
        DefaultTokenServices tokenServices = new DefaultTokenServices();

        //2.设置令牌生成和存储策略(tokenStore)
        tokenServices.setTokenStore(tokenStore);

        //3.设置是否支持令牌刷新(访问令牌过期了，是否支持通过令牌刷新机制，延长令牌有效期)
        tokenServices.setSupportRefreshToken(true);

        //4.设置令牌增强(默认令牌会比较简单，使用的就是UUID, 没有业务数据，
        //就是简单随机字符串，但现在希望使用jwt方式)(不写会使用默认生成UUID)
        TokenEnhancerChain tokenEnhancer = new TokenEnhancerChain();
        tokenEnhancer.setTokenEnhancers(Arrays.asList(jwtAccessTokenConverter));
        tokenServices.setTokenEnhancer(tokenEnhancer);

        //5.设置访问令牌有效期
        tokenServices.setAccessTokenValiditySeconds(3600);//1小时

        //6.设置是否支持刷新令牌(是否支持使用刷新令牌再生成新令牌)
        tokenServices.setSupportRefreshToken(true);
        //7.设置刷新令牌有效期
        tokenServices.setRefreshTokenValiditySeconds(3600*72);//3天

        return tokenServices;
    }

    /**
     * 假如我们要做认证，我们输入了用户名和密码，然后点提交
     * 提交到哪里(url-去哪认证)，这个路径是否需要认证？还有令牌过期了，
     * 我们要重新生成一个令牌，哪个路径可以帮我们重新生成？
     * 如下这个方法就可以提供这个配置
     * @param security
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
                //1.定义(公开)要认证的url(permitAll()是官方定义好的)
                //公开oauth/token_key端点
                .tokenKeyAccess("permitAll()") //return this

                //2.定义(公开)令牌检查的url
                //公开oauth/check_token端点
                .checkTokenAccess("permitAll()")

                //3.允许客户端直接通过表单方式提交认证
                .allowFormAuthenticationForClients();
    }

    /**
     * 认证中心是否要给所有的客户端发令牌呢？假如不是，那要给哪些客户端
     * 发令牌，是否在服务端有一些规则的定义呢？
     * 例如：老赖不能做飞机，不能做高铁
     * @param clients
     * @throws Exception
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        //super.configure(clients);
        clients.inMemory()

                //定义客户端的id(客户端提交用户信息进行认证时需要这个id)
                .withClient("gateway-client")

                //定义客户端密钥(客户端提交用户信息时需要携带这个密钥)
                .secret(passwordEncoder.encode("123456"))

                //定义作用范围(所有符合规则的客户端)
                .scopes("all")

                //允许客户端基于密码方式，刷新令牌方式实现认证
                .authorizedGrantTypes("password","refresh_token");
    }
}

测试三

  1. 登陆访问测试

image-20211204123059855

  1. 登陆成功以后，会在postman控制台显示如下格式信息

image-20211204123109832

  1. 检查token信息

image-20211204123120582

  1. 请求访问ok，在postman控制台会显示如下格式信息

image-20211204123131335

  1. 刷新令牌应用测试

image-20211204123144181

  1. 请求访问ok，在postman控制台会显示如下格式信息

image-20211204123156598

SSO-resource业务实现

业务描述

资源服务工程为一个业务数据工程，此工程中数据在访问通常情况下是受限访问，例如有些资源有用户，都可以方法，有些资源必须认证才可访问，有些资源认证后，有权限才可以访问。

设计架构

image-20211204123206278

pom依赖

   <dependencies>
        <!--spring boot web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--nacos discovery-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--nacos config-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--sentinel-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

        <!--在资源服务器添加此依赖,只做授权,不做认证,添加完此依赖以后,
        在项目中我们要做哪些事情?对受限访问的资源可以先判断是否登录了,
        已经认证用户还要判断是否有权限?
        -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-oauth2</artifactId>
        </dependency>
    </dependencies>

bootstrap.yml文件

server:
  port: 8881
spring:
  application:
    name: sso-resource
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848
        file-extension: yml

启动类

package com.jt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ResourceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ResourceApplication.class,args);
    }
}

controller

package com.jt.resource.controller;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/resource")
public class ResourceController {

    /**
     * 查询资源
     * @return
     */
    @PreAuthorize("hasAuthority('sys:res:list')")
    @GetMapping
    public String doSelect(){
        return "Select Resource ok";
    }
    /**
     * 创建资源
     * @return
     */
    @PreAuthorize("hasAuthority('sys:res:create')")
    @PostMapping
    public String doCreate(){
        return "Create Resource OK";
    }
    /**
     * 修改资源
     * @return
     */
    @PreAuthorize("hasAuthority('sys:res:update')")
    @PutMapping
    public String doUpdate(){
        return "Update Resource OK";
    }
    /**
     * 删除资源
     * @return
     */
    @DeleteMapping
    public String doDelete(){
        return "Delete resource ok";
    }
}

config

TokenConfig

package com.jt;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;


/**
 * 在此配置类中配置令牌的生成，存储策略，验签方式(令牌合法性)。
 */
@Configuration
public class TokenConfig {

    /**
     * 配置令牌的存储策略,对于oauth2规范中提供了这样的几种策略
     * 1)JdbcTokenStore(这里是要将token存储到关系型数据库)
     * 2)RedisTokenStore(这是要将token存储到redis数据库-key/value)
     * 3)JwtTokenStore(这里是将产生的token信息存储客户端，并且token
     * 中可以以自包含的形式存储一些用户信息)
     * 4)....
     */
    @Bean
    public TokenStore tokenStore(){
        //这里采用JWT方式生成和存储令牌信息
        return new JwtTokenStore(jwtAccessTokenConverter());
    }
    /**
     * 配置令牌的创建及验签方式
     * 基于此对象创建的令牌信息会封装到OAuth2AccessToken类型的对象中
     * 然后再存储到TokenStore对象，外界需要时，会从tokenStore进行获取。
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(){
        JwtAccessTokenConverter jwtAccessTokenConverter=
                new JwtAccessTokenConverter();
        //JWT令牌构成：header(签名算法，令牌类型),payload(数据部分),Signing(签名)
        //这里的签名可以简单理解为加密，加密时会使用header中算法以及我们自己提供的密钥，
        //这里加密的目的是为了防止令牌被篡改。（这里密钥要保管好，要存储在服务端）
        jwtAccessTokenConverter.setSigningKey(SIGNING_KEY);//设置密钥
        return jwtAccessTokenConverter;
    }

    /**
     * JWT 令牌签名时使用的密钥(可以理解为盐值加密中的盐)
     * 1)生成的令牌需要这个密钥进行签名
     * 2)获取的令牌需要使用这个密钥进行验签(校验令牌合法性，是否被篡改过)
     */
    private static final String SIGNING_KEY="auth";
}

ResourceConfig

package com.jt;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.TokenStore;

/**
 * 思考?对于一个系统而言,它资源的访问权限你是如何进行分类设计的
 * 1)不需要登录就可以访问(例如12306查票)
 * 2)登录以后才能访问(例如12306的购票)
 * 3)登录以后没有权限也不能访问(例如会员等级不够不让执行一些相关操作)
 */
@Configuration
@EnableResourceServer
//启动方法上的权限控制,需要授权才可访问的方法上添加@PreAuthorize等相关注解
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        //super.configure(http);
        //1.关闭跨域攻击
        http.csrf().disable();
        //2.放行相关请求
        http.authorizeRequests()
                .antMatchers("/resource/**")
                .authenticated()
                .anyRequest().permitAll();
    }
}

测试

  1. 不携带令牌访问

image-20211204123221597

  1. 携带令牌访问

image-20211204123230602

  1. 没有访问权限

image-20211204123239283

SSO-gateway业务实现

pom文件

 <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--假如网关层面进行限流,添加如下依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>
    </dependencies>

bootstrap.yml文件

server:
  port: 9000
spring:
  application:
    name: sso-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848
        file-extension: yml
    sentinel:
      transport:
        dashboard: localhost:8180
      eager: true
    gateway:
      routes:
        - id: router01
          uri: lb://sso-resource
          predicates:
            - Path=/sso/resource/**
          filters:
            - StripPrefix=1
        - id: router02
          uri: lb://sso-auth
          predicates:
            - Path=/sso/oauth/**
          filters:
            - StripPrefix=1
      globalcors: #跨域配置(写到配置文件的好处是可以将其配置写到配置中心)
        corsConfigurations:
          '[/**]':
            allowedOrigins: "*"
            allowedHeaders: "*"
            allowedMethods: "*"
            allowCredentials: true

启动类

package com.jt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ApiGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
}

测试一

  1. 基于网关进行登陆访问测试

image-20211204123310650

  1. 基于网关进行资源访问测试

image-20211204123342555

image-20211204123417592

image-20211204123428009

拓展

  1. 将网关配置写进配置中心
  2. 进行限流网关服务实现前端请求的限流

网关配置中心

  1. nacos配置中心
image-20211204123439768
  1. 注释掉yml里写进配置中心的配置
image-20211204123457806

设置限流操作

image-20211204123513610

测试二

  1. 进入前端页面, 点击查询资源发起访问请求, 当访问频率超过设置的规则前端会报出429错误状态码
  2. html文件添加提示, 如果状态码为429则弹框提示访问频率太快

image-20211204123527207

  1. 这时前端页面则会给出提示(更加完善)

image-20211204123539608

# SSO-UI业务实现

pom文件

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

启动类

package com.jt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class UIApplication {
    public static void main(String[] args) {
        SpringApplication.run(UIApplication.class, args);
    }
}

前端页面

在resource目录下创建static目录, 添加HTML文件

login.html

<!doctype html>
<html lang="en">
<head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
    <title>login</title>
</head>
<body>
<div class="container"id="app">
    <h3>Please Login</h3>
    <form>
        <div class="mb-3">
            <label for="usernameId" class="form-label">Username</label>
            <input type="text" v-model="username" class="form-control" id="usernameId" aria-describedby="emailHelp">
        </div>
        <div class="mb-3">
            <label for="passwordId" class="form-label">Password</label>
            <input type="password" v-model="password" class="form-control" id="passwordId">
        </div>
        <button type="button" @click="doLogin()" class="btn btn-primary">Submit</button>
    </form>
</div>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script>
    var vm=new Vue({
        el:"#app",//定义监控点，vue底层会基于此监控点在内存中构建dom树
        data:{ //此对象中定义页面上要操作的数据
            username:"",
            password:""
        },
        methods: {//此位置定义所有业务事件处理函数
            doLogin() {
                //1.定义url
                let url = "http://localhost:9000/sso/oauth/token"
                //2.定义参数
                let params = new URLSearchParams()
                params.append('username',this.username);
                params.append('password',this.password);
                params.append('client_id',"gateway-client");
                params.append('client_secret',"123456");
                params.append('grant_type',"password");
                //3.发送异步请求
                axios.post(url, params)
                    .then((response) => {//ok
                         alert("login ok")
                         let result=response.data;
                         console.log("result",result);
                         //将返回的访问令牌存储到浏览器本地对象中
                         localStorage.setItem("accessToken",result.access_token);
                         location.href="/resource.html";
                         //启动一个定时器,一个小时以后,向认证中心发送刷新令牌
                     })
                    .catch((e)=>{
                        console.log(e);
                    })
            }
        }
    });
</script>
</body>
</html>

resource.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <h1>The Resource Page</h1>
    <button onclick="doSelect()">查询我的资源</button>
    <button onclick="doUpdate()">修改我的资源</button>
</div>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script>
    function doSelect(){
        let url="http://localhost:9000/sso/resource";
        //获取登录后,存储到浏览器客户端的访问令牌
        let token=localStorage.getItem("accessToken");
        //发送请求时,携带访问令牌
        axios.get(url,{headers:{"Authorization":"Bearer "+token}})
            .then(function (response){
                alert("select ok")
                console.log(response.data);
            })
            .catch(function (e){//失败时执行catch代码块
                if(e.response.status==401){
                    alert("请先登录");
                    location.href="/login.html";
                }else if(e.response.status==403){
                    alert("您没有权限")
                }
                console.log("error",e);
            })
    }
    function doUpdate(){
        let url="http://localhost:9000/sso/resource";
        //获取登录后,存储到浏览器客户端的访问令牌
        let token=localStorage.getItem("accessToken");
        console.log("token",token);
        //发送请求时,携带访问令牌
        axios.put(url,"",{headers:{"Authorization":"Bearer "+token}})
            .then(function (response){
                alert("update ok")
                console.log(response.data);
            })
            .catch(function (e){//失败时执行catch代码块
                console.log(e);
                if(e.response.status==401){
                    alert("请先登录");
                    location.href="/login.html";
                }else if(e.response.status==403){
                    alert("您没有权限")
                }
                console.log("error",e);
            })
    }
</script>
</body>
</html>

测试

  1. 打开浏览器进行访问测试

image-20211204123555119

image-20211204123605182

用户日志信息处理

添加用户日志插入方法

1.封装日志属性

  1. pojo层新建log属性类
  2. 根据数据库log表封装属性
package com.jt.system.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import java.io.Serializable;
import java.util.Date;

/**
 * 基于此对象封装用户行为日志
 * 执行操作, 访问方法, 访问时长
 * @author 刘杰
 * @title: Log
 * @projectName CGB2107IVProject
 * @date 2021/11/4 14:15
 */

@Data
@TableName("tb_logs")
public class Log implements Serializable {

    private static final long serialVersionUID = 3054471551801044482L;
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String operation;
    private String method;
    private String params;
    private Long time;
    private String ip;

//    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @TableField("createdTime")
    private Date createdTime; // = new Date();
    private Integer status;
    private String error;

}

2. controller层

package com.jt.system.controller;

import com.jt.system.pojo.Log;
import com.jt.system.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author 刘杰
 * @title: LogController
 * @projectName CGB2107IVProject
 * @date 2021/11/4 15:23
 */

@RestController
@CrossOrigin
@RequestMapping("/log")
public class LogController {

    @Autowired
    private LogService logService;

    @PostMapping
    public void doInsertLog(@RequestBody Log log) {
        logService.insertLog(log);
    }

}

3. service层

  • service接口
package com.jt.system.service;

import com.jt.system.pojo.Log;

/**
 * 用户行为日志业务逻辑对象
 * @author 刘杰
 * @title: LogService
 * @projectName CGB2107IVProject
 * @date 2021/11/4 15:10
 */
public interface LogService {


    /**
     * 保存用户行为日志
     *
     * @param log 日志
     */
    void insertLog(Log log);
}
  • service实现类
package com.jt.system.service.impl;

import com.jt.system.dao.LogMapper;
import com.jt.system.pojo.Log;
import com.jt.system.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

/**
 * @author 刘杰
 * @title: LogServiceImpl
 * @projectName CGB2107IVProject
 * @date 2021/11/4 15:14
 */
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogMapper logMapper;

    /**
     * 插入日志
     * @Async 描述的方法会在异步线程中执行, 不由Web(tomcat)服务线程执行, 而是spring自带的线程池中执行
     * 优点: 不会长时间阻塞Web服务线程
     * 但是: @Async注解的应用有个前提, 需要在启动类上启动异步执行(添加@EnableAsync)
     * @param log 日志
     */
    @Async
    @Override
    public void insertLog(Log log) {
        String tName = Thread.currentThread().getName();
        System.out.println("LogServiceImpl.thread.name: " + tName);
        logMapper.insert(log);
    }
}

4.mapper层

package com.jt.system.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.system.pojo.Log;
import org.apache.ibatis.annotations.Mapper;

/**
 * 用户行为日志数据对象
 *
 * @author 刘杰
 * @title: LogMapper
 * @projectName CGB2107IVProject
 * @date 2021/11/4 14:21
 */
@Mapper
public interface LogMapper extends BaseMapper<Log> {


}
  • 使用了继承自BaseMapper的insert方法

source模块获取用户行为日志

1.pojo封装日志属性

package com.jt.resource.pojo;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * 基于此对象封装用户行为日志
 * 执行操作, 访问方法, 访问时长
 * @author 刘杰
 * @title: Log
 * @projectName CGB2107IVProject
 * @date 2021/11/4 14:15
 */

@Data
public class Log implements Serializable {

    private static final long serialVersionUID = 3054471551801044482L;
    private Long id;
    private String username;
    private String operation;
    private String method;
    private String params;
    private Long time;
    private String ip;
    private Date createdTime;
    private Integer status;
    private String error;

}

2…自定义 @RequiredLog注解

package com.jt.resource.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 定义RequiredLog注解, 通过此注解对需要进行日志记录的方法进行描述
 *
 *
 * @author 刘杰
 * @title: RequiredLog
 * @projectName CGB2107IVProject
 * @date 2021/11/4 16:23
 */

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredLog {

    String value() default "";
}

3. 设计自定义注解@RequiredLog的设计链(日志行为业务处理)

package com.jt.resource.aspect;

import com.jt.resource.annotation.RequiredLog;
import com.jt.resource.pojo.Log;
import com.jt.resource.service.RemoteLogService;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.lang.reflect.Method;
import java.util.Date;

/**
 * /@Aspect 描述的类型为一个切面类型, 在此类中可以定义:
 * 1)切入点(切入扩展逻辑的位置: 例如权限控制, 日志记录, 事务处理)
 * 在@Aspect描述的类中, 通常使用 @Pointcut 进行定义
 * 2)通知方法(在切入点对应的目标方法执行前后要执行的逻辑需要写到这个方法里)
 * 在@Aspect描述的类中, 通过@Before,@After, @Aroud,,,,这样的注解进行描述
 * a:@Before 切入点方法执行之前执行
 * b:@After 切入点方法执行之后执行
 * c:@Aroud 切入点方法执行之前和之后都可以执行(最重要)
 * d:@AfterReturning 切入点方法成功执行之后执行
 * e:@AfterThrowing 切入点方法执行时出了异常会执行
 *
 * @author 刘杰
 * @title: LogAspect
 * @projectName CGB2107IVProject
 * @date 2021/11/4 16:28
 */

@Aspect
@Component
public class LogAspect {

    /**
     * @Pointcut 注解用于定义切入点, 此注解中的内容为切入点表达式
     * @annotation 为注解方式的切入点表达式, 此方式的表达式为一种细粒度的表达式
     * 因为它可以精确到方法, 例如我们现在利用RequiredLog注解描述方法时, 由它描述的方法就是一个切入点方法
     * 做日志
     */

//    @Pointcut("bean(resourceController)") //不能精确到具体某个方法, Controller里所有方法都是切入点方法
    @Pointcut("@annotation(com.jt.resource.annotation.RequiredLog)")
//    @Pointcut("execution(* com.jt.resource.controller.ResourceController. *(..) )")
    public void doLog() {
        //此方法中不允许写任何内容, 只负责承载@Pointcut注解
    }

    /**
     * /@Around描述的方法为Aspect中的一个环绕通知方法, 在此方法内部可以控制对目标方法的调用
     *
     * @param joinPoint 连接点对象, 此对象封装了要执行的切入点信息, 可以基于此对象对切入点方法进行反射调用
     * @return {@link Object} 目标执行链中切入点方法的返回值
     * @throws Throwable throwable
     */
    @Around("doLog()")
    public Object doAround(ProceedingJoinPoint joinPoint)throws Throwable{
        int status=1;//状态
        String error=null;//错误信息
        long time=0l;//执行时长
        long t1=System.currentTimeMillis();
        try {
            //手动调用目标执行链(这个执行链中包含切入点方法~目标方法)
            Object result = joinPoint.proceed();
            long t2=System.currentTimeMillis();
            time=t2-t1;
            return result;
        }catch (Throwable e){
            long t3=System.currentTimeMillis();
            time=t3-t1;
            status=0;
            error=e.getMessage();
            throw e;
        }finally {
            saveLog(joinPoint,time,status,error);
        }
    }
    //存储用户行为日志
    private void saveLog(ProceedingJoinPoint joinPoint,long time,
                         int status,String error)throws Throwable{
        //1.获取用户行为日志
        //1.1获取目标对象类型(切入点方法所在类的类型)
        Class<?> targetClass = joinPoint.getTarget().getClass();
        //1.2.获取目标方法
        //1.2.1获取方法签名(包含方法信息,....)
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        //1.2.2获取方法对象
        Method targetMethod=
                targetClass.getDeclaredMethod(signature.getName(),signature.getParameterTypes());
        //1.3获取方法上的RequiredLog注解内容
        //1.3.1获取目标方法上注解
        RequiredLog requiredLog=targetMethod.getAnnotation(RequiredLog.class);
        //1.3.2获取注解中的内容(这个内容为我们定义的操作名)
        String operation=requiredLog.value();
        //1.4获取目标方法名(类名+方法名)
        String targetMethodName=targetClass.getName()+"."+targetMethod.getName();
        //1.5获取目标方法执行时传入的参数
        String params=new ObjectMapper().writeValueAsString(joinPoint.getArgs());
        //1.6获取登录用户名(参考了Security官方的代码)
        String username=(String)
                SecurityContextHolder.getContext()
                        .getAuthentication()
                        .getPrincipal();
        //1.7获取ip地址(从当前线程获取request对象,然后基于request获取ip地址)
        //String ip="192.168.1.100";
        ServletRequestAttributes requestAttributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String ip=requestAttributes.getRequest().getRemoteAddr();
        //2.将用户行为日志,封装到Log对象
        Log logInfo=new Log();
        logInfo.setIp(ip);
        logInfo.setUsername(username);
        logInfo.setOperation(operation);
        logInfo.setMethod(targetMethodName);
        logInfo.setParams(params);
        logInfo.setTime(time);
        logInfo.setStatus(status);
        logInfo.setError(error);
        logInfo.setCreatedTime(new Date());
        System.out.println("logInfo="+logInfo);
    }
}

4. 使用注解

  • @RequiredLog注解描述的方法为日志切入点方法
/**
 * @author 刘杰
 * @title: ResourceController
 * @projectName CGB2107IVProject
 * @description: TODO
 * @date 2021/11/3 14:13
 */
@RestController
@RequestMapping("/resource")
public class ResourceController {
    /**
     * 查询资源
     * /@PreAuthorize注解描述的方法为权限控制切入点方法
     * /@RequiredLog描述的方法为日志切入点方法
     *
     * @return {@link String}
     */
    @RequiredLog("查询日志") // 注解中的内容为一个操作名称
    @PreAuthorize("hasAuthority('sys:res:list')")
    @GetMapping
    public String doSelect(){
        return "查询成功";
    }

使用feign调用system服务里的insert方法存入数据库

1. 创建service服务调用接口

package com.jt.resource.service;

import com.jt.resource.pojo.Log;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

/**
 * 远程日志服务接口
 * @author 刘杰
 * @title: RemoteLogService
 * @projectName CGB2107IVProject
 * @date 2021/11/5 10:21
 */

@FeignClient(value = "sso-system", contextId = "remoteLogService")
public interface RemoteLogService {

    @PostMapping("/log")
    void insertLog(@RequestBody Log log);
}

2.传递封装的log对象

  • 在设计的执行链中注入service
    @Autowired
private RemoteLogService logService;
  • 将log对象通过参数传输
logService.insertLog(logInfo);

package com.jt.resource.aspect;

import com.jt.resource.annotation.RequiredLog;
import com.jt.resource.pojo.Log;
import com.jt.resource.service.RemoteLogService;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.lang.reflect.Method;
import java.util.Date;

/**
 * /@Aspect 描述的类型为一个切面类型, 在此类中可以定义:
 * 1)切入点(切入扩展逻辑的位置: 例如权限控制, 日志记录, 事务处理)
 * 在@Aspect描述的类中, 通常使用 @Pointcut 进行定义
 * 2)通知方法(在切入点对应的目标方法执行前后要执行的逻辑需要写到这个方法里)
 * 在@Aspect描述的类中, 通过@Before,@After, @Aroud,,,,这样的注解进行描述
 * a:@Before 切入点方法执行之前执行
 * b:@After 切入点方法执行之后执行
 * c:@Aroud 切入点方法执行之前和之后都可以执行(最重要)
 * d:@AfterReturning 切入点方法成功执行之后执行
 * e:@AfterThrowing 切入点方法执行时出了异常会执行
 *
 * @author 刘杰
 * @title: LogAspect
 * @projectName CGB2107IVProject
 * @date 2021/11/4 16:28
 */

@Aspect
@Component
public class LogAspect {

    /**
     * @Pointcut 注解用于定义切入点, 此注解中的内容为切入点表达式
     * @annotation 为注解方式的切入点表达式, 此方式的表达式为一种细粒度的表达式
     * 因为它可以精确到方法, 例如我们现在利用RequiredLog注解描述方法时, 由它描述的方法就是一个切入点方法
     * 做日志
     */

//    @Pointcut("bean(resourceController)") //不能精确到具体某个方法, Controller里所有方法都是切入点方法
    @Pointcut("@annotation(com.jt.resource.annotation.RequiredLog)")
//    @Pointcut("execution(* com.jt.resource.controller.ResourceController. *(..) )")
    public void doLog() {
        //此方法中不允许写任何内容, 只负责承载@Pointcut注解
    }

    /**
     * /@Around描述的方法为Aspect中的一个环绕通知方法, 在此方法内部可以控制对目标方法的调用
     *
     * @param joinPoint 连接点对象, 此对象封装了要执行的切入点信息, 可以基于此对象对切入点方法进行反射调用
     * @return {@link Object} 目标执行链中切入点方法的返回值
     * @throws Throwable throwable
     */
    @Around("doLog()")
    public Object doAround(ProceedingJoinPoint joinPoint)throws Throwable{
        int status=1;//状态
        String error=null;//错误信息
        long time=0l;//执行时长
        long t1=System.currentTimeMillis();
        try {
            //手动调用目标执行链(这个执行链中包含切入点方法~目标方法)
            Object result = joinPoint.proceed();
            long t2=System.currentTimeMillis();
            time=t2-t1;
            return result;
        }catch (Throwable e){
            long t3=System.currentTimeMillis();
            time=t3-t1;
            status=0;
            error=e.getMessage();
            throw e;
        }finally {
            saveLog(joinPoint,time,status,error);
        }
    }
    //存储用户行为日志
    private void saveLog(ProceedingJoinPoint joinPoint,long time,
                         int status,String error)throws Throwable{
        //1.获取用户行为日志
        //1.1获取目标对象类型(切入点方法所在类的类型)
        Class<?> targetClass = joinPoint.getTarget().getClass();
        //1.2.获取目标方法
        //1.2.1获取方法签名(包含方法信息,....)
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        //1.2.2获取方法对象
        Method targetMethod=
                targetClass.getDeclaredMethod(signature.getName(),signature.getParameterTypes());
        //1.3获取方法上的RequiredLog注解内容
        //1.3.1获取目标方法上注解
        RequiredLog requiredLog=targetMethod.getAnnotation(RequiredLog.class);
        //1.3.2获取注解中的内容(这个内容为我们定义的操作名)
        String operation=requiredLog.value();
        //1.4获取目标方法名(类名+方法名)
        String targetMethodName=targetClass.getName()+"."+targetMethod.getName();
        //1.5获取目标方法执行时传入的参数
        String params=new ObjectMapper().writeValueAsString(joinPoint.getArgs());
        //1.6获取登录用户名(参考了Security官方的代码)
        String username=(String)
                SecurityContextHolder.getContext()
                        .getAuthentication()
                        .getPrincipal();
        //1.7获取ip地址(从当前线程获取request对象,然后基于request获取ip地址)
        //String ip="192.168.1.100";
        ServletRequestAttributes requestAttributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String ip=requestAttributes.getRequest().getRemoteAddr();
        //2.将用户行为日志,封装到Log对象
        Log logInfo=new Log();
        logInfo.setIp(ip);//后续获取
        logInfo.setUsername(username);
        logInfo.setOperation(operation);
        logInfo.setMethod(targetMethodName);
        logInfo.setParams(params);
        logInfo.setTime(time);
        logInfo.setStatus(status);
        logInfo.setError(error);
        logInfo.setCreatedTime(new Date());
        System.out.println("logInfo="+logInfo);
        //3. 将日志对象通过feign方式传递到远程sso-system服务
        logService.insertLog(logInfo);
    }

    @Autowired
    private RemoteLogService logService;

}
偶尔也吹晚风
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring cloud单点登录
findhappy117的博客
02-09 2万+
基于springcloud的单点登录服务及基于zuul的网关服务(解决了通过zuul转发到认证服务之后session丢失问题)
spring cloud 单点登录
03-26
这是一个spring cloud的单点登录例子程序，使用redis存储session
SpringCloud项目，使用JWT+Gateway方案，实现单点登录
Haokunhaokun的博客
08-27 1937
JWT+Gateway实现单点登录
spring cloud微服务分布式云架构-单点登录（SSO）
weixin_33748818的博客
03-21 1364
单点登录SSO（Single Sign-On）是身份管理中的一部分。SSO的一种较为通俗的定义是：SSO是指访问同一服务器不同应用中的受保护资源的同一用户，只需要登录一次，即 通过一个应用中的安全验证后，再访问其他应用中的受保护资源时，不再需要重新登录验证。 Spring Cloud大型企业分布式微服务云架构源码请加一七九一七四三三八零 目前的企业应用环境中，往往有很多的应用系统，如办公自动化（O...
浅谈微服务架构中实现单点登录
最新发布
颜淡慕潇
06-21 1575
在微服务架构中实现单点登录需要全面考虑安全性、令牌管理、认证和授权机制以及微服务间的通信方式。采用 OAuth 2.0 和 OpenID Connect 等标准协议，可以有效地实现单点登录，并确保系统的可扩展性和安全性。通过结合 API Gateway 和 Service Mesh 等技术，可以进一步简化开发和运维工作，实现一个高效、安全的微服务架构。
Spring+ Spring cloud + SSO单点登录应用认证
weixin_34205076的博客
11-06 598
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringCloud之SSO单点登录-基于Gateway和OAuth2的跨系统统一认证和鉴权详解
热门推荐
踏雨歌青春，诗酒趁年华
05-29 1万+
本文详述了如何利用SpringCloud、Gateway和OAuth2实现跨系统的统一认证和鉴权。文章介绍了SSO单点登录的概念和优势，通过具体的配置和代码示例，讲解了如何搭建一个安全、高效的认证中心，实现用户只需一次登录即可访问多个系统的目标，从而提高系统安全性和用户体验。
SpringCloud入门 —— SSO 单点登录
~~~~~~~BUG FLY~~~~~~~~~
11-29 5445
前言 本文适合初学者，如有不足或错误之处，还请大家在下方留言指正。 一、SSO单点登录是什么？ 单点登录简介 单点登录SSO (Single Sign On) 在多个系统中，在一个多系统共存的环境下，用户在一处登录后，就不用在其他系统中登录，也就是用户的一次登录能得到其他所有系统的信任。 单系统登录 在之前我们做的单系统登录，它的核心是Cookie，Cookie携带会话id在浏览器与服务器之间维护会话状态。 Cookie 和 Session 众所周知，HTTP是无状态的协议，这意味着服务器无法确认用户的信息
springCloud-master_单点登录_springCloud单点登录_SpringCloud系统_springclou
10-01
在"springCloud-master_单点登录_springCloud单点登录_SpringCloud系统_springcloud eureka单点登录"这个项目中，我们将重点探讨如何在SpringCloud环境中实现单点登录（Single Sign-On，简称SSO）。 单点登录是一种...
Spring Cloud 集成OAuth2实现身份认证和单点登录
07-20
本篇将深入探讨如何利用Spring Cloud集成OAuth2来实现身份认证和单点登录（Single Sign-On，简称SSO）。 OAuth2是一种授权框架，它允许第三方应用获取资源所有者的特定资源，同时保护了资源所有者的隐私信息。在...
SpringCloud实现SSO 单点登录的示例代码
08-26
在分布式系统中，单点登录（Single Sign-On，简称SSO）是一种常见的身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而无需多次登录。在SpringCloud框架中，我们可以利用其组件和特性来实现SSO功能...
spring cloud oauth2 zuul 单点登录 认证授权
01-08
spring cloud框架下的单点登录sso技术 oauth2实现的认证 授权 以及zuul作为网关路由 可以参考学习使用
Spring Cloud 集成OAuth2实现身份认证和单点登录源代码
01-21
Spring Cloud 集成OAuth2实现身份认证和单点登录，绝对有帮助
springboot 2.1.6 sso.rar 单点登陆-springcloud(Greenwich.SR2),springSecurey,oauth2
07-03
springcloud-sso-单点登陆实例代码,采用springboot2.1.6，springcloud Greenwich.SR2及security,oauth2,security-jwt及其他适配组件构建而成
Spring-Cloud单点登陆
xaxaxa1213的博客
08-19 253
Caused by: java.nio.charset.MalformedInputException: Input length = 1 确定非yml配置类文件内容问题,换编码类型 因为这个小问题,找了一上午
SpringCloud简单的单点登录
June_FlyingFrost的博客
05-20 3247
单点登录 单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。 类似于京东，淘宝等… 个人理解 代码实现(案例) 1.导入redis依赖包 <dependency> <groupId>redis.clients</group...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偶尔也吹晚风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值