【SpringBoot】SpringBoot学习笔记——整合数据库

已于 2022-01-30 01:09:22 修改
阅读量1.6k 收藏 1
点赞数
文章标签： spring boot 数据库 redis
于 2022-01-29 00:18:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lht964249279/article/details/122738401
版权

文章目录

4. SpringBoot整合数据库

4.1 整合Redis缓冲

是一个基于内存的单线程高性能Key-Value型数据库。整个数据库统统加载在内存当中进行操作，定期通过异步操作把数据库数据flash到硬盘上进行保存。因为是纯内存操作，Redis性能非常出色，每秒可以处理超过10万次读写操作，是已知性能最高的Key-Value数据库。

Redis可以存储键和五种不同类型的值之间的映射。键的类型只能为字符串，值支持五种数据类型：string(字符串)、list(列表)、set(集合)、hash(哈希类型)、Sorted Set(有序集合)。

4.1.1 Redis数据库操作

  • 对字符串的操作
  • 对List集合的操作
  • 对set集合的操作
  • 对Hash集合的操作
  • 对zset的操作

参考https://blog.csdn.net/icetime17/article/details/45767559

4.1.2 SpringBoot整合Redis

  • 创建SpringBoot项目

    首先创建Spring Boot Web项目，添加Redis依赖，并添加Redis的缓冲连接池，常用的缓冲连接池为Lettuce和Jedis。Jedis在多线程使用同一个连接时，线程是不安全的，所以要使用连接池，得为每一个Jedis实例分配一个连接。Lettuce在多线程使用统一连接实例时，线程是安全的。Redis默认使用Lettuce连接池，依赖如下：

    <!--Redis相关依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--Lettuce pool缓冲连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

  • 配置文件

    在application.properties中，添加如下配置信息：

    # Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=8  
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=-1ms
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=8 
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0

  • 创建实体类

    创建一个City类：

    package com.shenziyi.db.entity;

import java.io.Serializable;

public class City implements Serializable {
    private int id;
    private String name;
    private String country;

    public City(int id, String name, String country) {
        this.id = id;
        this.name = name;
        this.country = country;
    }

    @Override
    public String toString() {
        return "City{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", country='" + country + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }
}

  • 创建Controller

    实体类及Redis的连接信息添加完成后，创建一个CityController进行测试：

    package com.shenziyi.db.controller;

import com.shenziyi.db.entity.City;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;

public class CityController {

    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @GetMapping("/")
    public void testRedis(){
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        //添加字符串
        ops.set("name", "beixi");
        String name=ops.get("name");
        System.out.println(name);
        ValueOperations opsForValue = redisTemplate.opsForValue();
        City city=new City(1, "北京", "中国");
        //添加实体类
        opsForValue.set("city", city);
        Boolean exists = redisTemplate.hasKey("city");
        System.out.println("redis是否存在相应的key："+exists);
        //删除
        redisTemplate.delete("city");
        //更新
        redisTemplate.opsForValue().set("city", new City(2, "山西","中国"));
        //查询
        City c2 = (City) redisTemplate.opsForValue().get("city");
        System.out.println("从redis数据库中获取city："+c2.toString());

    }
}

    RedisTemplate和StringRedisTemplate都是Spring Data Redis为我们提供的模板类，用来对数据进行操作，都通过Spring提供的Serializer序列化到数据库。其中StringRedisTemplate是RedisTemplate的子类，只针对键值都是字符串的数据进行操作，采用的序列化方案是StringRedisSerializer，而RedisTemplate可以操作对象，采用的序列化方案是JdkSerializationRedisSerializer。在SpringBoot中默认提供这两个模板类，RedisTemplate和StringRedisTemplate都提供了Redis的基本操作方法。

    RedisTemplate和StringRedisTemplate还为我们提供了下面几个数据访问方法：

    • opsForList:操作list数据。
    • opsForSet:操作Set数据。
    • opsForZSet:操作ZSet数据。
    • opsForHash:操作Hash数据。

  • 测试：在浏览器中输入http://localhost:8080/访问，观察控制台上打印的日志信息：
    在这里插入图片描述
    也可以使用RedisClient客户端工具查看Redis缓冲数据库中的数据：
    在这里插入图片描述

4.1.3 Redis缓冲在SpringBoot项目中的应用

在开发中，如果以相同的查询条件频繁查询数据库，会给数据库带来很大的压力。因此，我们需要对查询出来的数据进行缓存，这样客户端只需从数据库查询一次数据，然后放入缓存中，以后再次查询的时候可以从缓存中读取，这样便提高了数据的访问速度，并发步骤如下：

  1. 准备工作

    开启Redis数据库，创建Spring Boot Web项目。使用MySql数据库创建user表用于项目开发数据的存储，如下：
    在这里插入图片描述

  2. 导入依赖

    在pom.xml文件中导入Redis数据库、持久层MyBatis、MySQL驱动等相关依赖(引入MySQL JDBC驱动时要根据自己安装的MySQL版本而定，win+r输入cmd，在终端输入mysql --version查看自己的MySQL版本，我的是8.0.24)：

    <!-- mybatis 与 spring boot 2.x的整合包 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--mysql JDBC驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--jedis连接池-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

  3. 配置文件

    接下来在application.yml中配置Redis连接信息、MySQL数据库连接等相关信息：

    server:
  port: 8081

#数据库连接
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: admin123

  ## Redis 配置
  redis:
    ## Redis数据库索引（默认为0）
    database: 0
    ## Redis服务器地址
    host: localhost
    ## Redis服务器连接端口
    port: 6379
    ## Redis服务器连接密码（默认为空）
    password:
    jedis:
      pool:
        ## 连接池最大连接数（使用负值表示没有限制）
        #spring.redis.pool.max-active=8
        max-active: 8
        ## 连接池最大阻塞等待时间（使用负值表示没有限制）
        #spring.redis.pool.max-wait=-1
        max-wait: -1
        ## 连接池中的最大空闲连接
        #spring.redis.pool.max-idle=8
        max-idle: 8
        ## 连接池中的最小空闲连接
        #spring.redis.pool.min-idle=0
        min-idle: 0
    ## 连接超时时间（毫秒）
    timeout: 1200

  #将themilef的默认缓存禁用，热加载生效
  thymeleaf:
    cache: false

  #mybatis的下划线转驼峰配置
  configuration:
    map-underscore-to-camel-case: true

    #另外一种打印语句的方式
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

#打印sql时的语句
logging:
  level:
    com:
      acong:
        dao: debug

  4. 实体类

    创建与数据库相对应的User实体类：

    package com.shenziyi.db.entity;

import java.io.Serializable;


public class User implements Serializable {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

  5. 创建持久层

    接着是Mapper持久层Dao，这里主要用注解写比较方便，也可以使用MyBatis的XML配置文件写SQL语句：

    package com.shenziyi.db.Dao;

import com.shenziyi.db.entity.User;
import org.apache.ibatis.annotations.*;

import java.util.List;


@Mapper
public interface UserDao {

    @Select("select * from user")
    List<User> queryAll();

    @Select("select * from user where id = #{id}")
    User findUserById(int id);


}

  6. 业务层

    创建UserService，这里主要使用Redis模板来写：

    package com.shenziyi.db.service;


import com.shenziyi.db.Dao.UserDao;
import com.shenziyi.db.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.TimeUnit;


@Service
public class UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private RedisTemplate redisTemplate;

    public List<User> queryAll() {
        return userDao.queryAll();
    }

    /**
     * 获取用户策略：先从缓存中获取用户，没有则取数据表中 数据，再将数据写入缓存
     */
    public User findUserById(int id) {
        String key = "user_" + id;

        ValueOperations<String, User> operations = redisTemplate.opsForValue();

        //判断redis中是否有键为key的缓存
        boolean hasKey = redisTemplate.hasKey(key);

        if (hasKey) {
            User user = operations.get(key);
            System.out.println("从缓存中获得数据：" + user.getName());
            System.out.println("------------------------------------");
            return user;
        } else {
            User user = userDao.findUserById(id);
            System.out.println("查询数据库获得数据：" + user.getName());
            System.out.println("------------------------------------");

            // 写入缓存
            operations.set(key, user, 5, TimeUnit.HOURS);
            return user;
        }
    }
}

  7. 控制层

    创建UserController，用于暴露访问接口：

    package com.shenziyi.db.controller;


import com.shenziyi.db.entity.User;
import com.shenziyi.db.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;


@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/queryAll")
    public List<User> queryAll(){
        List<User> lists = userService.queryAll();
        return lists;
    }

    @RequestMapping("/findUserById")
    public Map<String, Object> findUserById(@RequestParam int id){
        User user = userService.findUserById(id);
        Map<String, Object> result = new HashMap<>();
        result.put("id", user.getId());
        result.put("name", user.getName());
        result.put("pwd", user.getPwd());
        return result;
    }
}

  8. 测试

    这里主要使用RedisTemplate来对Redis操作，每次访问controller暴露的接口，首先判断Redis缓存中是否存在该数据，若不存在就从数据库中读取数据，然后保存在Redis缓存中，当下次访问的时候，就直接从缓存中取出来。这样就不用每次都执行SQL语句，能够提高访问速度。但是当数据保存到缓存中时，需要设置键和值及超时删除，注意设置超市删除缓存时间不用太长，否则会给服务器压力。
    启动SpringBoot项目，在浏览器输入http://localhost:8081/findUserById?id=1，当我们第一次访问数据时从数据库获取，再次访问时则从缓存中获取保存的数据：(没有id为3的数据，所以报错)
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

4.2 整合MySQL

4.2.1 SpringBoot整合MySQL

SpringBoot集成MySQL非常简单。SpringBoot连接数据库有四种方式：

  • 采用JDBC直接连接。
  • 采用JdbcTemplate连接。
  • 采用SpringDataJPA连接。
  • 框架连接。

采用JDBC方式直接连接烦琐，易错，我们直接略过，不做考虑。通过MyBatis、SpringDataJPA等连接，我们后续再讲。JdbcTemplate在JDBC的基础上做了大量的封装，本节采用JdbcTemplate连接MySQL。

  1. 引入依赖

    <!-- MySQL连接Java的驱动程序 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- 支持通过JDBC连接数据库 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

  2. 添加数据库配置

    在application.yml文件中添加如下配置：

    spring:
  datasource:
    #MySQL连接信息   serverTimezone=GMT%2B8解决时区时间差报错问题
    url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8
    # 账号
    username: root
    # 密码
    password: admin123
    # 驱动
    driver-class-name: com.mysql.jdbc.Driver

  3. 设计表和实体

    配置完信息之后，在test数据库中新建一张用户表user(之前已建好)

    表和数据准备好之后，在项目中新建User实体类：

    package com.shenziyi.entity;


public class User {
    private int id;
    private String name;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

  4. 控制层

    创建UserController类：

    package com.shenziyi.controller;


import com.shenziyi.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Controller
public class UserController {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @ResponseBody
    @RequestMapping("/list")
    public List mySqlTest(){
        String sql="select * from user";
        /*query()是JdbcTemplate对象中的方法，RowMapper对象可以查询数据库中的数据*/
        List<User>users=jdbcTemplate.query(sql,new RowMapper<User>(){
            @Override
            /*RowMapper对象通过调用mapRow()方法将数据库中的每一行数据封装成User对象，并返回*/
            public User mapRow(ResultSet rs,int i)throws SQLException {
                User user = new User();
                user.setId(rs.getInt("id"));
                user.setName(rs.getString("name"));
                user.setPassword(rs.getString("password"));
                return user;
            }
        });
        System.out.println("查询成功: "+users);
        return users;
    }
}

    代码解释如下：

    • JdbcTemplate：JDBC连接数据库的工具类。
    • Query()：query()是JdbcTemplate对象中的方法，RowMapper可以查询数据库中的数据。
    • mapRow():RowMapper对象通过调用mapRow()方法将数据库中的每一行数据封装成User对象并返回。

访问http://localhost:8080/list路径即可查询数据信息：
在这里插入图片描述
在这里插入图片描述

shen子怡
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot 学习笔记+完整教程
04-28
Spring boot(后续用*表示) helloworld * 返回 json 数据 * 使用其他 json 转换框架 * 全局异常捕捉 * JPA 连接数据库 * 配置 JPA * 整合 JPA 保存数据 * 使用 JdbcTemplate 保存数据 * 常用配置 * 静态资源处理 * 实现任务调度 * 普通类调用 Bean * 使用模板引擎 * 集成 JSP * 集成 servlet * 集成 Fliter 和 Linstener * 拦截器 HandlerInterceptor * 系统启动任务 CommandLineRunner * 集成 Junit 单元测试 * 读取系统环境变量 * 使用自定义 properties * 改变默认包扫᧿ * 自定义启动 Banner * 导入 spring XML 配置文件 * 热部署 * 监控和管理生产环境 * starter 详解 * 依赖的版本 * 文件上传 * 集成 redis 缓存 * 之 spring cache * 集成 EHCache * 分布式 Session 共享
SpringBoot学习笔记——尚硅谷
03-21
SpringBoot学习笔记 尚硅谷 SpringBoot学习笔记 尚硅谷
作者推荐 | 企业级缓存技术解析，你必须知道的“9“大技术问题与常见误区
最新发布
世界上并没有完美的程序，但是我们并不因此而沮丧，因为写程序就是一个不断追求完美的过程。
01-31 1033
若要持续优化站点或应用程序，最迅速且最显著的方式无疑是采用缓存技术。我们通常会将常用或需耗费大量资源与时间生成的数据进行缓存，以确保后续使用的流畅性。尽管缓存的优点颇多，但在实际应用中，其效果往往不尽如人意。假设缓存能将性能提升至100%，但实际效果往往只有80%、70%或更低，甚至可能导致性能严重下降。尤其在分布式缓存的使用中，这种现象尤为明显。相信众多读者已经注意到，本文尚有两个问题尚未剖析。
2022Java面试题，非常全面
weixin_44059780的博客
04-10 1万+
目录 JAVA基础 MySql MyBatis Spring SpringMVC SpringBoot Linux Redis 跨域问题 若依框架 jwt（token） Docker Thymeleaf MySQL存储过程 JAVA基础 1.基本数据类型 ： byte short int long float double char boolean byte char short 平级 int float long double 2.引用数据类型：数组，类...
是什么让Redis“气急败坏”回击：13年来，总有人想替Redis换套新架构
朱小厮的博客
08-16 1539
点击上方“朱小厮的博客”，选择“设为星标”后台回复"书"，获取后台回复“k8s”，可领取k8s资料今年年中，一位前谷歌、前亚马逊的工程师推出了他创作的开源内存数据缓存系统 Dragonfly，用 C/C++ 编写，基于 BSL 许可（Business Source License）分发。根据过往的基准测试结果来看， Dragonfly 可能是世界上最快的内存存储系统，它提供了对 Memcached...
springboot整合redis
weixin_34202952的博客
11-07 70
一、redis简介 开源免费用C语言编写的，是一个高性能的key-value分布式内存数据库并支持持久化的nosql数据库。 特点: Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用 Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储 Redis支持数据的备份，即master-slave...
【springboot】基于jdbctemplate封装一个轻量级orm框架
月月鸟先森的博客
01-19 3938
最近一直在使用springboot做后台系统，之前数据操作框架选型hibernate太重，mybaits又是半自动化的，怎么都感觉用着不方便，所以先用jdbctemplate快速灵活的实现业务功能，但是后来发现还是需要封装一套数据操作的基础框架，使开发更加高效，免除大量的重复劳动，jdbctemplate灵活快速并且封装好了一些基础功能，我们要做的就是对数据进行内部映射，对外提供方法接口，使得开发...
SpringBoot封装统一返回数据格式
菜鸟逆袭之路
04-23 2485
一、定义统一响应结果类 名称 描述 code 状态码：0成功，-1失败 msg 响应信息 data 返回数据 public class ResultReturn implements Serializable { private static final long serialVersionUID = 580579298763...
KeyDB重量发布6.3.0开源版
华为云官方博客
05-16 862
近日， KeyDB 社区隆重发布了 6.3.0开源版本，将与华为加拿大研究院DCS团队2021-2022年合作的成果，深度优化的企业版的能力贡献给了开源社区。
SpringBoot学习（七）--封装Mybatis实现通用对象的增删改查
热门推荐
super-pf的博客
02-10 1万+
版权声明：作者原创，转载请注明出处。 本系列文章目录地址：http://blog.csdn.net/u011961421/article/details/79416510 简介 Mybatis的动态SQL拥有良好的灵活性和扩展性，但同时这也使得开发过程变得繁琐，单表的增删改查最原子操作都需要从Service实现到Sqlmap,一定程度上影响了开发效率，究此原因，博主结合自身经验通...
SpringBoot——封装JDBC使用
char_m的博客
12-26 2487
Spring Boot中可以在配置文件中直接进行数据库配置， spring.datasource.username= root spring.datasource.password= 123456 spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf-8 spring.datasource.driver-class-name=com.mysql.cj.jdbc.
SpringBoot经典学习笔记_springboot_SpringBoot经典学习笔记_
09-30
Springboot经典学习笔记，来源于csdn
SpringBoot学习笔记——AOP全局统一日志管理
12-21
一、前言 我们开发的Web系统都会有日志模块，用来记录对数据有进行变更的操作。一般都会记录请求的URL，请求的IP，执行的方法，操作人员等等。其目的可能是为了保留操作痕迹，防抵赖，或是记录系统运行情况，再有...
springboot学习思维笔记.xmind
06-19
springboot学习笔记 spring基础 Spring概述 Spring的简史 xml配置 注解配置 java配置 Spring概述 Spring的模块 核心容器CoreContainer Spring-Core Spring-Beans ...
2023年1000个优秀Github项目盘点
Lee达森的博客
01-07 2617
Github犹如一座繁星点点的灯塔，照亮了无数优秀的开源项目。最近，我有幸盘点了一千个Github上的优秀项目，从繁杂的代码库中探索出了那些璀璨的明珠。今天，我想与你们分享这份发现，让我们一起走进这个充满创意与智慧的世界。这一千个项目涵盖了各种各样的领域，包括但不限于人工智能、机器学习、Web开发、移动应用开发、游戏开发、数据科学等。这些项目不仅有着极高的技术含量，而且在创新性、实用性、易用性等方面也表现出了令人惊叹的品质。其中，一些项目致力于解决现实生活中的问题，如开发一款能够帮助残障人士更好地生活的人工
spring boot 1.封装分页插件pagehelp并做统一做返回值 2.封装SQL 3.redis在mybatis里面使用（大综合）
weixin_44728473的博客
06-25 928
spring boot 1.封装分页插件pagehelp并做统一做返回值 2.封装SQL 3.redis在mybatis里面使用（大综合）
SpringBoot返回值封装
m0_46252893的博客
03-15 3638
返回值封装
Spring Boot入门
qq_43330631的博客
09-20 305
springboot是什么 Spring Boot它本身并不提供Spring框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于Spring框架的应用程序。 也就是说，它并不是用来替代Spring的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具 同时它集成了大量常用的第三方库配置（例如Jackson, JDBC, Mongo, Redis, Mail等等...
SpringBoot整合Keycloak实现单点登录
liu320yj的博客
03-20 6825
Keycloak是一个开源的身份和权限访问管理工具，轻松为应用程序和安全服务添加身份验证，无需处理储存用户或者验证用户，其提供用户联合、强健的身份验证、用户管理和细粒度授权等功能。 搭建Keycloak服务器 本文使用docker compose安装keycloak，因为keycloak依赖数据库，在安装keycloak之前需要先安装数据库，本文使用mysql，具体的compose配置如下： version: '3.7' services: mysql: container_name: my
jQuery学习笔记——事件
06-08
好的，关于 jQuery 的事件，我可以和你分享一些学习笔记。 1. 绑定事件 在 jQuery 中，我们可以通过以下方式来绑定事件： ``` $(selector).event(function(){ // 事件处理程序 }) ``` 其中，`selector` 表示要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值