神奇cpp

这个屌丝很懒，什么也没留下！

热门标签

SpringCloud---SSO单点登录_springcloud sso

作者：神奇cpp | 2024-06-29 06:12:12

踩

springcloud sso

文章目录

学习流程
SSO-system业务实现
SSO-auth业务实现
SSO-resource业务实现
SSO-gateway业务实现
用户日志信息处理

学习流程

服务设计

创建sso父工程

添加父工程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
创建启动类, controller, service, pojo, dao(mapper), yml
配置yml(端口, 数据库, 服务注册/发现和配置)

创建sso-auth子工程

添加子工程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
创建启动类, service, pojo, config, yml
配置yml文件(端口, 服务发现, 配置中心)

创建sso-resource子工程

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

创建sso-gateway子工程

添加pom
创建启动类
创建yml

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

添加pom
创建启动类
resource下创建static目录
static下创建HTML文件

数据库

用户表(ID username password)

用户和角色关系表

用户角色和菜单关系表

用户菜单权限表

表结构设计

sql语句

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

方案一: 单次查询

基于用户ID查询用户对应的角色ID (查询出的角色ID可能是多个)

select role_id
from tb_user_roles
where user_id = 1;
1
2
3

基于角色ID查询用户对象的菜单ID

select menu_id
from tb_role_menus
where role_id in (1);
1
2
3

基于菜单ID查询菜单权限标识

select permission
from tb_menus
where id in (1, 2, 3);
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));
1
2
3
4
5
6
7

方案三: 多表关联查询

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;
1
2
3
4
5
6
7

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

service

UserService

public interface UserService {

    User selectUserByUsername(String username);

    List<String> selectUserPermissions(Long userId);
}

1
2
3
4
5
6
7

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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;

}
1
2
3
4
5
6
7
8
9
10
11
12

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

注意yml配置

测试

基于用户名查询用户信息

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

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>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

yml配置

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

1
2
3
4
5
6
7
8
9
10
11
12

启动类

使用@EnableFeignClients注解进行远程调用

@EnableFeignClients
@SpringBootApplication
public class AuthApplication {

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

1
2
3
4
5
6
7
8
9

测试一

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

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

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

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);
}
1
2
3
4
5
6
7
8
9

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;
        //返回给认证中心,认证中心会基于用户输入的密码以及数据库的密码做一个比对
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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;
}

1
2
3
4
5
6
7
8
9
10

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

测试二

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

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";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

测试三

登陆访问测试

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

检查token信息

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

刷新令牌应用测试

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

SSO-resource业务实现

业务描述

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

设计架构

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>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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

1
2
3
4
5
6
7
8
9
10
11
12
13

启动类

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);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

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";
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

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";
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

测试

不携带令牌访问

携带令牌访问

没有访问权限

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>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

启动类

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
2
3
4
5
6
7
8
9
10
11

测试一

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

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

拓展

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

网关配置中心

nacos配置中心

注释掉yml里写进配置中心的配置

设置限流操作

测试二

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

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

# SSO-UI业务实现
1

pom文件

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

1
2
3
4
5
6
7

启动类

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);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

前端页面

在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>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

测试

打开浏览器进行访问测试

用户日志信息处理

添加用户日志插入方法

1.封装日志属性

pojo层新建log属性类
根据数据库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;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

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);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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> {


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

使用了继承自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;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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 "";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

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 "查询成功";
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

使用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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.传递封装的log对象

在设计的执行链中注入service

    @Autowired
private RemoteLogService logService;
1
2

将log对象通过参数传输

logService.insertLog(logInfo);
1

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;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/神奇cpp/article/detail/768451