LEEYANGY

LEEYANGY 关注TA

拼搏百天

LEEYANGY

LEEYANGY

关注TA

拼搏百天

  • 加入社区2,064天
  • 写了322,476字

该文章投稿至Nemo社区   Java  板块 复制链接


springboot && springcloud alibaba

发布于 2022/10/17 11:00 10,078浏览 0回复 29,139字

上课内容，单纯记录一些内容，不是教程，仅供参考

springboot 项目创建 省略

    创建项目后简单连接数据库进行crud操作

springboot 默认使用 HikariDataSource 数据源(当然也可以使用druid之类得其它数据源)

    


pom文件中引入依赖

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>




application.properties 和 application.yml 配置文件 近乎一样

这里直接用yaml

server:
  port: 8888

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://ip:3306/blog?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai
    username: username
    password: password

mybatis:
  mapper-locations: classpath:/mappers/*Mapper.xml
  type-aliases-package: xyz.leeyangy.pojo


建包建类  因为没什么功能，暂时是这样，


用户表

id,name,age,birthday


mapper ， service ，service/impl

//    @Select("select * from m_user")
    //    查询所有用户
    List<User> getAll();



在springboot启动类上添加Mapper扫描注解，否则会报空指针异常，或者是需要自己在配置文件中添加Mapper类

添加Mapper扫描注解后


thymeleaf:

    添加命名空间

xmlns:th="http://www.thymeleaf.org"

标签省略


逆向工程：

    

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包-->
    <classPathEntry location="E:\mybatis-generator-core-1.3.7\lib\mysql-connector-java-8.0.29.jar"/>
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <commentGenerator>
            <property name="suppressDate" value="true"/>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true"/>
        </commentGenerator>
        <!--数据库链接URL，用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springbootclass"
                        userId="null" password="null">
        </jdbcConnection>
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <!-- 生成模型的包名和位置-->
        <javaModelGenerator targetPackage="xyz.leeyangy.pojo"
                            targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- 生成映射文件的包名和位置-->
        <sqlMapGenerator targetPackage="mappers"
                         targetProject="src/main/resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- 生成DAO的包名和位置-->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="xyz.leeyangy.dao" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 要生成的实体类与表的对应关系：
        1.tableName：是数据库中的表名或视图名
        2.domainObjectName：是实体类名
        3.每一张表都对应一个table
        -->
        <table tableName="user" domainObjectName="User"
               enableCountByExample="false" enableUpdateByExample="false"
               enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false"></table>
    </context>
</generatorConfiguration>


分页

    如何分页？

                mysql中使用关键字 limit即可实现

                实现算法如下：

                        当前页，合理猜想一定是从1开始，不会有第0页吧？

                        上一页 = 当前页 - 1    最小只能为1，理由同上

                        下一页 = 当前页 +1   当前页=总页数，则下一页=总页数

                         总页数=总记录数/页面容量(+1)，当不能整除时候需要+1

                         起始位置=（当前页-1）*页面容量

                         总记录数= 表中存储了多少记录，mysql中用count(*) 即可

                         举例子：

                        limit 0,3    0表示从0索引开始，3表示查询3条

                        limit 3,3     第一个3表示从3索引开始，第二个3表示查询3条

            到代码中

      dao层UserMapper      

package xyz.leeyangy.dao;
import org.apache.ibatis.annotations.Param;
import xyz.leeyangy.pojo.User;

import java.util.List;

public interface UserMapper {
//
    List<User> findUserByPage(@Param("start") int start, @Param("pageSize") int pageSize);
}


Service层 UserService

package xyz.leeyangy.service;

import xyz.leeyangy.pojo.User;

import java.util.List;

/**
 * @Author liyangyang
 * @Date: 2023/03/06 16:59
 * @Package xyz.leeyangy.service
 * @Version 1.0
 * @Description:
 */
public interface UserService {
    
    /**
    * @Param: [currentPage, pageSize]
    * @return: java.util.List<xyz.leeyangy.pojo.User>
    * @Author: liyangyang
    * @Date: 2023/3/7 0:25
    * @Description: 实现分页查询
     * 参数解释：
     *         currentPage  当前页
     *         pageSize     页面容量
    */
    List<User> findUserByPage(int currentPage, int pageSize);
}


impl  UserServiceImpl

package xyz.leeyangy.service.impl;

import org.springframework.stereotype.Service;
import xyz.leeyangy.dao.UserMapper;
import xyz.leeyangy.pojo.User;
import xyz.leeyangy.service.UserService;

import javax.annotation.Resource;
import java.util.List;

/**
 * @Author liyangyang
 * @Date: 2023/03/06 16:59
 * @Package xyz.leeyangy.service.impl
 * @Version 1.0
 * @Description:
 */

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

    /**
    * @Param: [currentPage, pageSize]
    * @return: java.util.List<xyz.leeyangy.pojo.User>
    * @Author: liyangyang
    * @Date: 2023/3/7 0:28
    * @Description: 实现分页查询
     * 实现算法如下：
     *
     *                         当前页，合理猜想一定是从1开始，不会有第0页吧？
     *
     *                         上一页 = 当前页 - 1    最小只能为1，理由同上
     *
     *                         下一页 = 当前页 +1   当前页=总页数，则下一页=总页数
     *
     *                          总页数=总记录数/页面容量(+1)，当不能整除时候需要+1
     *
     *                          起始位置=（当前页-1）*页面容量
     *
     *                          总记录数= 表中存储了多少记录，mysql中用count(*) 即可
     *
     *                          举例子：
     *
     *                         limit 0,3    0表示从0索引开始，3表示查询3条
     *
     *                         limit 3,3     第一个3表示从3索引开始，第二个3表示查询3条
    */
    @Override
    public List<User> findUserByPage(int currentPage, int pageSize) {
//        在这里需要实现上面提到的算法
        int start=(currentPage-1)*pageSize;
        return userMapper.findUserByPage(start,pageSize);
    }
}

最后跑到test测试类中测试一下是否正常

使用到junit测试类

package xyz.leeyangy;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import xyz.leeyangy.dao.UserMapper;
import xyz.leeyangy.service.UserService;

import javax.annotation.Resource;

@SpringBootTest
class SpringbootReverseApplicationTests {

	@Resource
	private UserMapper userMapper;

	@Resource
	private UserService userService;
	@Test
	void contextLoads() {

//		userMapper.findUserByPage().forEach(user -> System.out.println(user));
		userService.findUserByPage(2,3).forEach(user -> System.out.println(user));
	}

}


对分页进一步封装

新建一个工具类 PageUtil

package xyz.leeyangy.utils;

/**
 * @Author liyangyang
 * @Date: 2023/03/07 0:32
 * @Package xyz.leeyangy.utils
 * @Version 1.0
 * @Description:
 */

public class PageUtil {
    /**
     * 当前页
     */
    private int currentPage;

    /**
     * 上一页
     */
    private int prevPage;

    /**
     * 下一页
     */
    private int nextPage;

    /**
     * 页面容量
     */
    private int pageSize;

    /**
     * 总页数
     */
    private int totalPages;

    /**
     * 总记录数
     */
    private int totalSizes;

    /**
     * 无参构造
     */
//    public PageUtil() {
//    }
//
//    /**
//     * 有参构造
//     */
//    public PageUtil(int currentPage, int prevPage, int nextPage, int pageSize, int totalPages, int totalSizes) {
//        this.currentPage = currentPage;
//        this.prevPage = prevPage;
//        this.nextPage = nextPage;
//        this.pageSize = pageSize;
//        this.totalPages = totalPages;
//        this.totalSizes = totalSizes;
//    }

//    下面需要改造get方法
    public int getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    /**
     * @Param: []
     * @return: int
     * @Author: liyangyang
     * @Date: 2023/3/7 23:46
     * @Description: 获取上一页
     * 实现解释；
     * 当前页数小于或等于1，即返回1，否则-1
     */
    public int getPrevPage() {
        if (getCurrentPage() <= 1) {
            prevPage = 1;
        } else {
            prevPage = getCurrentPage() - 1;
        }
        return prevPage;
    }

    public void setPrevPage(int prevPage) {
        this.prevPage = prevPage;
    }

    /**
     * @Param: []
     * @return: int
     * @Author: liyangyang
     * @Date: 2023/3/8 0:16
     * @Description: 获取下一页
     * 实现解释：
     * 当前页==最大页数，下一页==当前页，否则+1
     */
    public int getNextPage() {
        if (getCurrentPage() == getTotalPages()) {
            nextPage = getCurrentPage();
        } else {
            nextPage = getCurrentPage() + 1;
        }
        return nextPage;
    }

    public void setNextPage(int nextPage) {
        this.nextPage = nextPage;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * @Param: []
     * @return: int
     * @Author: liyangyang
     * @Date: 2023/3/8 0:17
     * @Description: 获取总页数
     * 实现解释：
     * 总记录数取模页面容量==可分页最大数，能整除时候，既是最大容量，不能整除，需要向下取整，即是+1
     */
    public int getTotalPages() {
        if (totalSizes % pageSize == 0) {
            totalPages = getTotalSizes() / getPageSize();
        } else {
            totalPages = getTotalSizes() / getPageSize() + 1;
        }
        return totalPages;
    }

    public void setTotalPages(int totalPages) {
        this.totalPages = totalPages;
    }

    public int getTotalSizes() {
        return totalSizes;
    }

    public void setTotalSizes(int totalSizes) {
        this.totalSizes = totalSizes;
    }

//    @Override
//    public String toString() {
//        return "PageUtil{" +
//                "currentPage=" + currentPage +
//                ", prevPage=" + prevPage +
//                ", nextPage=" + nextPage +
//                ", pageSize=" + pageSize +
//                ", totalPages=" + totalPages +
//                ", totalSizes=" + totalSizes +
//                '}';
//    }
}

接下来是编写模板页面，这里使用到thymeleaf模板引擎

再次之前先封装User对象和Role角色对象

package xyz.leeyangy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Role {
    private Integer id;

    private String roleName;

}
package xyz.leeyangy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;

    private String name;

    private String password;

    private Date birthday;

    private Integer rid;

    private Role role;
}


query.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>查询结果如下</h1>
<table border="1px">
    <tr>
        <td>序号</td>
        <td>主键</td>
        <td>用户名</td>
        <td>密码</td>
        <td>生日</td>
        <td>关联字段</td>
        <td>角色主键</td>
        <td>角色类型</td>
    </tr>

    <tr th:each="user,status:${list}">
        <td th:text="${status.index+1}"></td>
        <td th:text="${user.id}"></td>
        <td th:text="${user.name}"></td>
        <td th:text="${user.password}"></td>
        <td th:text="${#dates.format(user.birthday,'yyyy-MM-dd')}"></td>
        <td th:text="${user.rid}"></td>
        <td th:text="${user.role.id}"></td>
        <td th:text="${user.role.roleName}"></td>
    </tr>
    <tr>
        <td>
            <a th:href="@{/getAllUser(currentPage=1)}">首页</a>
            <a th:href="@{/getAllUser(currentPage=${pageUtil.getPrevPage()})}">上一页</a>
            <a th:href="@{/getAllUser(currentPage=${pageUtil.getNextPage()})}">下一页</a>
            <a th:href="@{/getAllUser(currentPage=${pageUtil.getTotalPages()})}">尾页</a>
        </td>
    </tr>
<!--    <a th:href="/getAllUser"-->
</table>

</body>
</html>


controller层

package xyz.leeyangy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import xyz.leeyangy.dao.UserMapper;
import xyz.leeyangy.pojo.User;
import xyz.leeyangy.service.UserService;
import xyz.leeyangy.utils.PageUtil;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.List;

/**
 * @Author liyangyang
 * @Date: 2023/03/07 16:25
 * @Package xyz.leeyangy.controller
 * @Version 1.0
 * @Description:
 */

@Controller
public class UserController {

    @Resource
    private UserMapper userMapper;

    @Resource
    private UserService userService;

    /**
     * @Param: [currentPage, pageSize, request, session]
     * @return: java.lang.String
     * @Author: liyangyang
     * @Date: 2023/3/8 0:22
     * @Description: 实现建议分页查询效果
     * 参数解释：
     * currentPage 当前页
     * pageSize    页面容量
     * request     把数据库中，查到的数据，带到前端
     * session     把登录后的用户信息带到前端
     */
    @RequestMapping("/getAllUser")
    public String getAllUser(@RequestParam(defaultValue = "1") int currentPage, @RequestParam(defaultValue = "3") int pageSize, HttpServletRequest request, HttpSession session) {
//        创建工具类对象
        PageUtil pageUtil = new PageUtil();
//        设置当前页
        pageUtil.setCurrentPage(currentPage);
//        设置页面容量
        pageUtil.setPageSize(pageSize);
//        设置总记录数
        pageUtil.setTotalSizes(userMapper.count());
//        数据库查询结果
        List<User> list = userService.findUserByPage(currentPage, pageSize);
        request.setAttribute("list", list);
//        request.setAttribute("list", userService.findUserByPage(currentPage, pageSize));
//        带走数据
        request.setAttribute("pageUtil", pageUtil);
//        转发页面
        return "query";
    }

}


dao层需要新增方法，对总记录数进行统计

//    总记录数量
    int count();

UserMapper.xml中新增如下内容

内容解释：需要实际统计关联了权限的用户，如果某一用户，没有关联到对应role表中的id，就不统计该用户

<select id="count" resultType="java.lang.Integer">
        select count(*)
        from user u,
             role r
        where u.rid = r.id
    </select>

实现效果如下：



spring security

官方文档 Hello Spring Security :: Spring Security

    由于将前端和后端拆分开了，特此引入了，security框架：

   建表语句

create table sys_user
(
    id          bigint(20)   not null auto_increment primary key comment '主键',
    user_name   varchar(200) not null default 'null' comment '用户名',
    nick_name   varchar(200) not null default 'null' comment '呢称',
    `email`     varchar(64)           DEFAULT NULL COMMENT '邮箱',
    password    varchar(200) not null default 'null' comment '密码',
    status      char(1)               default '0' comment '账号状态 (0正常，1停用)',
    phonenumber varchar(32)           default null comment '用户名',
    sex         char(1)               default '2' comment '用户性别(0男，1女，2未知)',
    avatar      varchar(128)          default null comment '用户头像',
    user_type   char(1)               default '1' comment '用户类型(0管理员，1普通用户)',
    create_by   bigint(20)            default null comment '创建人用户id',
    create_time datetime              default null comment '创建时间',
    update_by   BIGINT(20)            default null comment '变更人',
    update_time datetime              default null comment '变更时间',
    del_flag    int(11)               default '0' comment '删除标志(0代表未删除，1代表已删除)'
) ENGINE = innodb
  default charset = utf8mb4 comment '用户表';

CREATE TABLE `sys_menu`
(
    `id`          bigint(20)  NOT NULL AUTO_INCREMENT COMMENT '菜单ID',
    `menu_name`   varchar(50) NOT NULL COMMENT '菜单名称',
    `path`        varchar(200) DEFAULT '' COMMENT '路由地址',
    `component`   varchar(255) DEFAULT NULL COMMENT '组件路径',
    `visible`     char(1)      DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）',
    `status`      char(1)      DEFAULT '0' COMMENT '菜单状态（0正常 1停用）',
    `perms`       varchar(100) DEFAULT NULL COMMENT '权限标识',
    `icon`        varchar(100) DEFAULT '#' COMMENT '菜单图标',
    `create_by`   bigint(20)   DEFAULT NULL COMMENT '创建者',
    `create_time` datetime     DEFAULT NULL COMMENT '创建时间',
    `update_by`   bigint(20)   DEFAULT NULL COMMENT '更新者',
    `update_time` datetime     DEFAULT NULL COMMENT '更新时间',
    `remark`      varchar(500) DEFAULT '' COMMENT '备注',
    `del_flag`    int(11)      DEFAULT '0',
    PRIMARY KEY (`id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 2029
  DEFAULT CHARSET = utf8mb4 COMMENT ='菜单权限表';

CREATE TABLE `sys_role`
(
    `id`          bigint(20) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
    `name`        varchar(128) DEFAULT NULL COMMENT '角色名称',
    `role_key`    varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
    `status`      char(1)    NOT NULL COMMENT '角色状态（0正常 1停用）',
    `del_flag`    int(1)       DEFAULT '0' COMMENT '删除标志（0代表存在 1代表删除）',
    `create_by`   bigint(20)   DEFAULT NULL COMMENT '创建者',
    `create_time` datetime     DEFAULT NULL COMMENT '创建时间',
    `update_by`   bigint(20)   DEFAULT NULL COMMENT '更新者',
    `update_time` datetime     DEFAULT NULL COMMENT '更新时间',
    `remark`      varchar(500) DEFAULT NULL COMMENT '备注',
    PRIMARY KEY (`id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 3
  DEFAULT CHARSET = utf8mb4 COMMENT ='角色信息表';

CREATE TABLE `sys_role_menu`
(
    `role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
    `menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜单ID',
    PRIMARY KEY (`role_id`, `menu_id`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 2
  DEFAULT CHARSET = utf8mb4 COMMENT ='角色和菜单关联表';

CREATE TABLE `sys_user_role`
(
    `user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
    `role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色ID',
    PRIMARY KEY (`user_id`, `role_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4 COMMENT ='用户和角色关联表';



redis：

redis一些基本数据类型，String，list，hash(存对象)，set(无序集合，且唯一)， sortedSet

简单实例

/        1.newjedis对象
        Jedis jedis = new Jedis("localhost", 6379);
//        2.jedis命令
//        System.out.println(jedis.ping());
//        清空数据库
        System.out.println("清空数据库====" + jedis.flushAll());
//        System.out.println(jedis.set("k1", "v11"));
//        System.out.println(jedis.get("k1"));
        jedis.mset("user", "lee", "age", "20", "passwd", "admin");
        List<String> list = jedis.mget("user", "age", "passwd");
        for (String str : list) System.out.println(str);

        System.out.println();
//        set类型
        jedis.sadd("a", "1", "2", "3", "4");
        jedis.sadd("b", "3", "4", "5", "6");

        System.out.println("a集合" + jedis.smembers("a"));
        System.out.println("b集合" + jedis.smembers("b"));

        Set<String> set1 = jedis.sdiff("a", "b");
//        for (String str:set){
        System.out.println("求a,b差集：" + set1);
//        }
        System.out.println("-------------");
        Set<String> set2 = jedis.sinter("a", "b");
        System.out.println("求a,b交集" + set2);

        System.out.println("-------------");

        Set<String> set3 = jedis.sunion("a", "b");
        System.out.println("求a，b并集" + set3);
        System.out.println("-------------");
        jedis.sdiffstore("c", "a", "b");
        jedis.sinterstore("d", "a", "b");
        jedis.sunionstore("e", "a", "b");
        System.out.println("查询保存a，b的差集" + jedis.smembers("c"));
        System.out.println("查询保存a，b的交集" + jedis.smembers("d"));
        System.out.println("查询保存a，b的并集" + jedis.smembers("e"));
        System.out.println("-------------");
//        sortedSet类型
        jedis.zadd("zkey", 100, "a");
        jedis.zadd("zkey", 75, "b");
        jedis.zadd("zkey", 50, "c");
        jedis.zadd("zkey", 25, "d");

        Map<String, Double> map = new HashMap<String, Double>();
        map.put("1", 40.0);
        map.put("3", 10.0);
        map.put("4", 50.0);
        map.put("2", 40.0);
        map.put("5", 90.0);
        jedis.zadd("myscore", map);
        System.out.println("sortedSet类型集合==" + jedis.zrange("zkey", 0, -1));
        System.out.println("sortedSet类型集合==" + jedis.zrange("myscore", 0, -1));
        System.out.println("sortedSet类型集合极端==" + jedis.zrangeByScore("myscore", 20.0, 80.0));

        //注意：第一个参数是键，第二个参数和第三个参数是分数，但是第二个值要大于第三个值
        Set<String> set4 = jedis.zrevrangeByScore("myscore", 40.0, 20.0);
        System.out.println(set4);

        //zrangewithscores获取分数和元素
        Set<Tuple> set5 = jedis.zrangeWithScores("myscore", 0, -1);
        for (Tuple t : set5)
            System.out.println(t.getScore() + "  " + t.getElement() + "  " + t.getBinaryElement() + "  " + t.getClass());

//       查询指定成员
        System.out.println("查询指定成员:" + jedis.zscore("myscore", "3"));

//        移除指定的成员
//         第一个参数表示键，后面所有参数表示要移除的成员，如果成员不存在，则忽略
//        jedis.zrem("zkey", "张三1","张三2","张三3","李四");


mp(mybatis plus)

......


springboot自动装配原理：

......


spring security

啃了很久，终于啃下来了，感谢b站up三更草堂

使用该框架，需要自行定义配置类，明白用户-角色

spring security 核心组件

SecurityContext、SecurityContextHolder、Authentication、Userdetails 和 AuthenticationManager


Authentication 
authentication 认证，在Spring Security 中Authentication用来表示当前用户是谁，一般来讲你可以理解为authentication就是一组用户名密码信息。Authentication也是一个接口


SecurityContext
安全上下文，通过校验之后，用户的验证信息存在SecurityContext中

UserDetails
想要基于数据库认证，实体类必须实现这个接口

UserDetailsService
用户类必须要实现UserDetails接口，还需要实现UserDetailsService接口，与实体类User(实现了UserDetails接口)
相对应的还要在应用层中实现UserDetailsService接口，提供了loadUserByUserName方法，通过该方法获取UserDetails


AuthenticationManager
AuthenticationManager 是一个接口，它只有一个方法，接收参数为Authentication，该类作用是校验Authentication，验证失败抛Authentication相关异常；

关于密码问题，启用了安全框架之后，需要启用密码加密，否则会提示警告xxxx需要开启



Spring Cloud Alibaba

建立父子项目

最外层的pom文件中添加依赖


nacos注册中心，单机模式和集群模式。




maven依赖
<dependencies>
        <!--配置测试依赖包的版本依赖，不需要进行版本锁定-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-angine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>


    <dependencyManagement>
        <dependencies>
            <!--配置springboot的版本锁定-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--配置spring cloud alibaba的版本锁定-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.2.5.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--配置spring cloud版本锁定-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

子项目：

子项目1

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>xyz.leeyangy</groupId>
        <artifactId>springcloud-parent</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>common-api</artifactId>
    <packaging>jar</packaging>

    <name>common-api</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--添加web支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--添加nacos服务注册发现-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!--引入nacos的配置-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!--支持feign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>
</project>

子项目2

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>xyz.leeyangy</groupId>
        <artifactId>springcloud-parent</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>stock-nacos</artifactId>
    <packaging>jar</packaging>

    <name>stock-nacos</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>xyz.leeyangy</groupId>
            <artifactId>common-api</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>
</project>

子项目3

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>xyz.leeyangy</groupId>
        <artifactId>springcloud-parent</artifactId>
        <version>1.0</version>
    </parent>

    <artifactId>order-nacos</artifactId>
    <version>1.1</version>
    <packaging>jar</packaging>

    <name>order-nacos</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>xyz.leeyangy</groupId>
            <artifactId>common-api</artifactId>
            <version>1.0</version>
        </dependency>
    </dependencies>
</project>

其它都一样的配置

本文标签
 {{tag}}

如果内容侵犯了您的版权,请联系站长处理

点了个评