四阶段--day09--单点登录系统连接数据库登录以及服务之间调用的功能扩展实现

最新推荐文章于 2024-03-28 10:07:54 发布

心猿意码~~

最新推荐文章于 2024-03-28 10:07:54 发布

阅读量564

点赞数 1

文章标签：数据库 sql mysql

本文链接：https://blog.csdn.net/weixin_58580280/article/details/120025299

版权

2.1 将指定的jt-sso.sql文件在mysql或者MariaDB中执行创建此数据库

7 Pojo对象逻辑实现-mvc的model层

8 Dao对象逻辑实现--持久层

9 Service对象逻辑实现--业务层

9.1 定义UserService接口

9.2 定义UserService接口实现类

10 Controller对象逻辑实现--mvc的控制层

11 启动服务进行访问测试

三认证服务工程中Feign应用进行远程服务调用

一扩展业务需求描述

1 增加数据库访问

登录用户信息来自数据库(用户自身信息以及用户对应的权限信息)
将上传的文件信息写入到数据库(自己做)
将登录操作,文件上传操作的操作日志写入到数据库.(自己做)

2 增加服务之间的调用

认证服务调用系统服务(获取用户以及用户权限)
认证服务与资源服务都调用系统服务(将日志传递给系统服务,进行数据的持久化)-自己做

二系统服务设计及实现

1 业务描述

系统服务jt-system工程用于提供其它服务需要的基础数据,例如用户信息,日志信息的记录等,其关键表设计例如:

在这里插入图片描述

项目结构如图所示:

2 数据初始化

2.1 将指定的jt-sso.sql文件在mysql或者MariaDB中执行创建此数据库

第一步:登录mysql

mysql -uroot -proot

第二步:通过source指令执行jt-sso文件,创建数据库,文件放哪里,路径就写哪里

source d:/jt-sso.sql

第三步:show tables; 查看数据库内的所有表格

3 创建sca-system系统工程

创建sca-system工程，此工程作为02-sca-files的子工程进行业务实现

在这里插入图片描述

4 添加项目核心依赖

        <!--1.数据库访问相关-->
        <!--1.1 mysql 数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--1.2 mybatis plus 插件-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </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>
        <!--Web 服务相关-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--如果需要测试,就添加测试类依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

5 创建项目配置文件

在项目resources包中添加bootstrap.yml文件

server:
  port: 8061
spring:
  application:
    name: sca-system
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848
        file-extension: yml
  datasource:  #尽量写到配置中心中,可以动态调整
    url: jdbc:mysql:///jt-sso?serverTimezone=Asia/Shanghai&characterEncoding=utf8
    username: root
    password: root

6 创建项目启动类以及测试类

1) 在项目中添加启动类

package com.jt;

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

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

2) 在项目中test下添加单元测试类，测试数据库连接

package com.jt;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

@SpringBootTest
public class DataSourceTests {
    @Autowired
    private DataSource dataSource;//HikariDataSource连接池--属于享元设计模式
    @Test
    void testGetConnection() throws SQLException {
        Connection conn=
        dataSource.getConnection();
        System.out.println(conn);
    }
}

3)启动测试类,后台返回一个连接池对象即为成功连接数据库

HikariProxyConnection@1548269356 wrapping com.mysql.cj.jdbc.ConnectionImpl@6e1ae763

7 Pojo对象逻辑实现-mvc的model层

创建system.pojo包,添加项目User对象，用于封装用户信息

package com.jt.system.pojo;

import lombok.Data;

import java.io.Serializable;

@Data//lombok省略set,get,toString()等
public class User implements Serializable {//实现序列化为了更好地传输对象数据
    //setting中勾选设置序列化id
    private static final long serialVersionUID = 4831304712151465443L;
    private Long id;
    private String username;
    private String password;
    private String status;
}

其中,设置序列化的id:

1.勾选设置序列化id操作

2. 光标放到User上,ALT+Enter 即可生成序列化id

8 Dao对象逻辑实现--持久层

1) 创建UserMapper接口，并定义基于用户名查询用户信息，基于用户id查询用户权限信息的方法

package com.jt.system.dao;

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

import java.util.List;

@Mapper
public interface UserMapper extends BaseMapper<User> {
//可以使用selecOne()方法查,现在使用的是sql注解的查询方法
    /**
     * 基于用户名获取用户信息
     * @param username
     * @return
     */
    @Select("select id,username,password,status " +
            "from tb_users " +
            "where username=#{username}")
    User selectUserByUsername(String username);

    /**
     * 基于用户id查询用户权限
     * @param userId 用户id
     * @return 用户的权限
     * 涉及到的表:tb_user_roles,tb_role_menus,tb_menus
     */
    @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);

}

但是多表联查方案二把相同因素和查询条件都使用and连接,不能轻易被看出

2) 创建UserMapperTests类，先对业务方法做单元测试,测试代码是否能够执行成功

package com.jt;

import com.jt.system.pojo.User;
import com.jt.system.dao.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class UserMapperTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    void testSelectUserByUsername(){
        User user =
        userMapper.selectUserByUsername("admin");
        System.out.println(user);
    }
    @Test
    void testSelectUserPermissions(){
        List<String> permission=
        userMapper.selectUserPermissions(1L);
        System.out.println(permission);
    }
}

9 Service对象逻辑实现--业务层

创建UserService接口及实现类，定义用户及用户权限查询逻辑

9.1 定义UserService接口

package com.jt.system.service;

import com.jt.system.pojo.User;

import java.util.List;

public interface UserService {
    User selectUserByUsername(String username);
    List<String> selectUserPermissions(Long userId);
}

9.2 定义UserService接口实现类

package com.jt.system.service.impl;

import com.jt.system.dao.UserMapper;
import com.jt.system.pojo.User;
import com.jt.system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@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) {
        return userMapper.selectUserPermissions(userId);
    }
}

10 Controller对象逻辑实现--mvc的控制层

package com.jt.system.controller;

import com.jt.system.pojo.User;
import com.jt.system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/user/")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/login/{username}")
    public User doSelectUserByUsername(
            @PathVariable("username") String username){
        return userService.selectUserByUsername(username);
    }
    @GetMapping("/permission/{userId}")
    public List<String> doSelectUserPermissions(
            @PathVariable("userId") Long userId){
        return userService.selectUserPermissions(userId);
    }
}

11 启动服务进行访问测试

启动nacos服务,启动sca-system工程服务启动类，打开浏览器根据控制层的请求方式分别对用户及用户权限信息的获取进行访问测试:

根据用户名查询:

根据权限查询:

三认证服务工程中Feign应用进行远程服务调用

1 业务描述

在认证sca-auth工程中,我们通过调用sca-system服务获取登录用户信息,用户权限信息.

2 认证工程中添加Feign依赖

在jt-auth工程中添加如下依赖

  <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>

3 创建Pojo包,封装user对象信息

package com.jt.auth.pojo;
import lombok.Data;
import java.io.Serializable;
@Data
public class User implements Serializable {
    private static final long serialVersionUID = 4831304712151465443L;
    private Long id;
    private String username;
    private String password;
    private String status;
}

4 Feign接口逻辑实现远程调用

1) 创建Feign接口，基于feign实现远程调用逻辑

package com.jt.auth.feign;
import com.jt.auth.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

@FeignClient(name = "sca-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);
}

2) 说明,feign接口定义后,需要在jt-auth启动类上添加@EnableFeignClients注解.

作用:

@EnableFeignClients注解描述启动类时,用于告诉springboot在启动时,
扫描启动类所在包或子包中的类,假如接口上有@FeignClient注解描述,
则对这样的接口创建其是实现类,在实现类内部帮我们进行远程服务调用

5 调用Feign接口逻辑

在sca-auth工程中的UserDetailServiceImpl中添加对feign接口的调用,

依赖注入feign接口
通过feign接口获取数据库用户名,权限和密码

package com.jt.auth.service;

import com.jt.auth.feign.RemoteUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 登录时用户信息的获取和封装会在此对象进行实现,
 * 在页面上点击登录按钮时,会调用这个对象的loadUserByUsername方法,
 * 页面上输入的用户名会传给这个方法的参数
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @Autowired
    private RemoteUserService remoteUserService;
    //UserDetails用户封装用户信息(认证和权限信息)
    @Override
    public UserDetails loadUserByUsername(String username)
            throws UsernameNotFoundException {
        //1.基于用户名查询用户信息(用户名,用户状态,密码,....)
        com.jt.auth.pojo.User user=
                remoteUserService.selectUserByUsername(username);
        //2.查询用户权限信息(后面会访问数据库)
        List<String> permissions=
        remoteUserService.selectUserPermissions(user.getId());
        System.out.println("permissions="+permissions);
        List<GrantedAuthority> authorities =
        AuthorityUtils.createAuthorityList(//权限以数组的形式展现
                permissions.toArray(new String[]{}));
        //3.对用户信息进行封装
        return new User(username,user.getPassword(),authorities);
    }
}

6 启动服务进行访问测试

第一步:启动sca-auth,sca-resource,sca-resource-gateway,sca-system,sca-resource-ui工程,然后从登录开始进行测试

第二步:网页输入登录页面的url,此时只能使用jt-sso数据库中的用户名和密码才能登录,跳转到上传文件的页面

第三步:上传文件后查看auth认证服务器的后台

第四步:没有权限的用户名进行登录查看效果

第五步:错误说明:如果此处上传成功了,是因为我们在资源认证阶段处理了异常,,所以,如果达到第四步的效果,就要把处理异常的方法注释掉!!!

心猿意码~~

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
四阶段--day09--单点登录系统连接数据库登录以及服务之间调用的功能扩展实现

目录一扩展业务需求描述1增加数据库访问2增加服务之间的调用二系统服务设计及实现1 业务描述2 数据初始化2.1 将指定的jt-sso.sql文件在mysql或者MariaDB中执行创建此数据库3 创建sca-system系统工程4 添加项目核心依赖5 创建项目配置文件6 创建项目启动类以及测试类7 Pojo对象逻辑实现-mvc的model层8 Dao对象逻辑实现--持久层9Service对象逻辑实现--业务层9.1定义UserSer...
复制链接

扫一扫