springboot+redis+jpa+mysql 搭建

最新推荐文章于 2023-01-01 10:45:28 发布
原创 最新推荐文章于 2023-01-01 10:45:28 发布 · 2k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#springboot #redis #mysql

本文详细介绍如何在SpringBoot项目中整合Redis，包括使用RedisTemplate替代Jedis的优势，以及具体的代码实现和配置步骤。

之前项目中用到redis缓存，这个在互联网企业中非常常用，这边就建立一个工程基于springboot,数据库用的是mysql连接方式采用的是jpa(也可以是mybits)，缓存用的是redis。

Springboot整合Redis有两种方式，分别是Jedis和RedisTemplate，这两者有何区别？

Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。其实在Springboot的官网上我们也能看到，官方现在推荐的是SpringDataRedis形式，相对于Jedis来说可以方便地更换Redis的Java客户端，其比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。

在这之前我在低版本的Springboot项目中一直使用Jedis操作Redis，但是我也意识到这种做法已经过时了，所以在升级了Springboot版本后特地在此篇中详细梳理一下，以后项目都会使用这个版本的整合方案，不再使用Jedis方式，不过我还是会再写一篇使用Jedis操作Redis的文章，因为从中能很清楚的看到其基本的工作方式，对Redis连接池的手动管理都能更清晰地体现出来。

工程源码github地址：源码地址

我这边现在自己mysql中建立一个数据库test_data,建立表user_info;表结构：

CREATE TABLE `user_info` (
  `id` varchar(20) NOT NULL,
  `name` varchar(200) DEFAULT NULL,
  `age` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC

然后使用idea建立spring boot工程，加入redis依赖，mysql依赖，jpa依赖，我这边最终使用的pom.xml是：

<?xml version="1.0" encoding="UTF-8"?>
<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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.test</groupId>
    <artifactId>redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
        </dependency>


        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.13</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.13</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>ooxml-schemas</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

这边配置本地redis 端口号在7006 ，ip是127.0.0.1

对应的配置文件是：

#服务启动端口
server :
  port :  9980

#数据库配置
spring:
  datasource:
    name: test
    url: jdbc:mysql://127.0.0.1:3306/test_data?useUnicode=true&characterEncoding=utf-8&autoReconnect=true&allowMultiQueries=true&useSSL=false&zeroDateTimeBehavior=convertToNull
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    filters: stat
    maxActive: 20
    initialSize: 1
    maxWait: 60000
    minIdle: 1
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxOpenPreparedStatements: 20
  redis:
    host: 127.0.0.1
    #redis密码，没有密码的可以用～表示
    password: ~
    port: 7006
#    pool:
#      max-active: 100
#      max-idle: 10
#      max-wait: 100000

# 日志输出
#logging:
#  file: ~/boot.log
#  level:
#    com.ibatis:DEBUG
#    root:DEBUG

task:
  cron:0 0/5 * * * ?

几个比较核心的类有，redisService对外接口，UserInfo,UserInfoService，RedisServiceImpl对redis操作主要依赖于redisTemplate这个工具类。

具体代码如下：

redisService:

package com.test.redis.service;

import java.util.List;

public interface RedisService {

     boolean set(String key, String value) throws Exception;

     String get(String key) throws Exception;

     boolean expire(String key, long expire) throws Exception;

     <T> boolean setList(String key, List<T> list) throws Exception;

     <T> List<T> getList(String key, Class<T> clz) throws Exception;

     long lpush(String key, Object obj) throws Exception;

     long rpush(String key, Object obj) throws Exception;

     void hmset(String key, Object obj) throws Exception;

     <T> T hget(String key, Class<T> clz) throws Exception;


     void del(String key) throws Exception;

     <T> List<T>  hmGetAll(String key, Class<T> clz) throws Exception;

     String lpop(String key) throws Exception;
}

 RedisServiceImpl

package com.test.redis.service.impl;

import com.test.redis.service.RedisService;
import com.test.redis.utils.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Created by xiaour.github.com on 2017/11/8.
 */
@Service("redisService")
@Transactional(rollbackFor = Exception.class)
public class RedisServiceImpl implements RedisService {

    private static int seconds=3600*24;

    @Autowired
    private RedisTemplate<String, ?> redisTemplate;

    @Override
    public boolean set(final String key, final String value) throws Exception {
        Assert.hasText(key,"Key is not empty.");
        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                connection.set(serializer.serialize(key), serializer.serialize(value));
                return true;
            }
        });
        return result;
    }

    public String get(final String key) throws Exception {
        Assert.hasText(key,"Key is not empty.");
        String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] value =  connection.get(serializer.serialize(key));
                return serializer.deserialize(value);
            }
        });
        return result;
    }

    public void del(final String key) throws Exception {
        Assert.hasText(key,"Key is not empty.");

        redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection conn) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                return conn.del(serializer.serialize(key));
            }
        });
    }



    @Override
    public boolean expire(final String key, long expire) {
        return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }

    @Override
    public <T> boolean setList(String key, List<T> list) throws Exception {
        Assert.hasText(key,"Key is not empty.");

        String value = JsonUtil.getJsonString(list);
        return set(key,value);
    }

    @Override
    public <T> List<T> getList(String key,Class<T> clz)  throws Exception{

        Assert.hasText(key,"Key is not empty.");

        String json = get(key);
        if(json!=null){
            List<T> list = JsonUtil.readJson2Array(json,clz);
            return list;
        }
        return null;
    }

    @Override
    public long lpush(final String key, Object obj)throws Exception {
        Assert.hasText(key,"Key is not empty.");

        final String value = JsonUtil.getJsonString(obj);
        long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long count = connection.lPush(serializer.serialize(key), serializer.serialize(value));
                return count;
            }
        });
        return result;
    }

    @Override
    public long rpush(final String key, Object obj) throws Exception{
        Assert.hasText(key,"Key is not empty.");

        final String value = JsonUtil.getJsonString(obj);
        long result = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                long count = connection.rPush(serializer.serialize(key), serializer.serialize(value));
                return count;
            }
        });
        return result;
    }

    @Override
    public void hmset(String key, Object obj)  throws Exception{
        Assert.hasText(key,"Key is not empty.");

        Map<byte[], byte[]> data=JsonUtil.readJsonByteMap(JsonUtil.getJsonString(obj));
        redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                connection.hMSet(serializer.serialize(key),data);
                return "";
            }
        });
    }

    @Override
    public <T> T hget(String key, Class<T> clz)  throws Exception{
        Assert.hasText(key,"Key is not empty.");

        return redisTemplate.execute(new RedisCallback<T>() {

            @Override
            public T doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();

                Map<String,Object> result;

                Map<byte[],byte[]> data=connection.hGetAll(serializer.serialize(key));
                result= new HashMap<>();
                for (Map.Entry<byte[], byte[]> entry: data.entrySet()) {
                    result.put(serializer.deserialize(entry.getKey()),serializer.deserialize(entry.getValue()));
                }

                return JsonUtil.json2Obj(JsonUtil.getJsonString(result),clz);
            }
        });
    }

    @Override
    public<T> List<T>  hmGetAll(String key,Class<T> clz) throws Exception{
        Assert.hasText(key,"Key is not empty.");

        List<Map<String,Object>> dataList= new ArrayList<>();
        return redisTemplate.execute(new RedisCallback<List<T>>() {
            @Override
            public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();

                Set<String> keysSet=redisTemplate.keys(key);
                Map<byte[],byte[]> data;
                Map<String,Object> result;
                for(String newKey:keysSet) {
                    data=connection.hGetAll(serializer.serialize(newKey));
                    result= new HashMap<>();
                    for (Map.Entry<byte[], byte[]> entry: data.entrySet()) {
                        result.put(serializer.deserialize(entry.getKey()),serializer.deserialize(entry.getValue()));
                    }
                    dataList.add(result);
                }
                return JsonUtil.readJson2Array(JsonUtil.getJsonString(dataList),clz);
            }
        });
    }

    @Override
    public String lpop(final String key) throws Exception{
        Assert.hasText(key,"Key is not empty.");

        String result = redisTemplate.execute(new RedisCallback<String>() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                byte[] res =  connection.lPop(serializer.serialize(key));
                return serializer.deserialize(res);
            }
        });
        return result;
    }
}

UserInfo 

package com.test.redis.domain;


import javax.persistence.Entity;
import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name="UserInfo")
public class UserInfo {

    @Id
    private String id;

    private String name;

    private int age;

    public UserInfo() {
    }

    public UserInfo(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


}

UserInfoRepository:
package com.test.redis.domain;

import org.springframework.data.repository.PagingAndSortingRepository;

public interface UserInfoRepository extends PagingAndSortingRepository<UserInfo, String> {
    public UserInfo findOneById(String id);

}

对外测试接口

package com.test.redis.web;


import com.test.redis.domain.UserInfo;
import com.test.redis.service.UserInfoService;
import com.test.redis.service.RedisService;
import com.test.redis.utils.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping(value="/test")
public class TestController {
	
	@Autowired
	private RedisService redisService;
	
	@Autowired  
    private UserInfoService userInfoService;

    @RequestMapping(value="/index")
    public String index(){
        return "hello world";
    }
    
    /**
     * 向redis存储值
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    @RequestMapping("/set/{key}/{value}")
    public String set(@PathVariable("key")String key, @PathVariable("value")String value) throws Exception{

        redisService.set(key, value);
        return "success";  
    }  
    
    /**
     * 获取redis中的值
     * @param key
     * @return
     */
    @RequestMapping("/get/{key}")
    public String get(@PathVariable("key")String key){
        try {
			return redisService.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";  
    }  
    
    /**
     * 获取数据库中的用户
     * @param id
     * @return
     */
    @RequestMapping("/getUser/{id}")  
    public String getUser(@PathVariable String id){
        try {
        	UserInfo user= userInfoService.findById(id);
			return JsonUtil.getJsonString(user);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "";  
    }

    @GetMapping( "/getdata")
    public String getData()
    {
        System.out.println("info has been gotten");
        return "info got";
    }


    @RequestMapping(value = "/saveUser/{name}/{age}" , method = RequestMethod.POST)
    public String putUser(@PathVariable String name,@PathVariable int age){
        try {
            userInfoService.saveData(name,age);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }


    public static void main(String[] args) {
        Map<String,Object> keyMap= new HashMap<>();
        keyMap.put("id","编号");
        keyMap.put("name","名称");

        String [] cnCloumn={"编号","名称"};

        System.out.println(Arrays.asList(convertMap(keyMap, cnCloumn)));

    }

    public static String[] convertMap(Map<String,Object> keyMap,String [] dataList){

        for(int i=0;i<dataList.length;i++){

            for(Map.Entry<String, Object> m:keyMap.entrySet()){
                if(m.getValue().equals(dataList[i])){
                   dataList[i]=m.getKey();
                }
            }
        }

        return dataList;
    }


    public static String getName(String name,String add){
        return null;
    }

    public static void testGetClassName() {
        // 方法1：通过SecurityManager的保护方法getClassContext()
        String clazzName = new SecurityManager() {
            public String getClassName() {
                return getClassContext()[1].getName();
            }
        }.getClassName();
        System.out.println(clazzName);
        // 方法2：通过Throwable的方法getStackTrace()
        String clazzName2 = new Throwable().getStackTrace()[1].getClassName();
        System.out.println(clazzName2);
        // 方法3：通过分析匿名类名称()
        String clazzName3 = new Object() {
            public String getClassName() {
                String clazzName = this.getClass().getName();
                return clazzName.substring(0, clazzName.lastIndexOf('$'));
            }
        }.getClassName();
        System.out.println(clazzName3);
        //方法4：通过Thread的方法getStackTrace()
        String clazzName4 = Thread.currentThread().getStackTrace()[2].getClassName();
        System.out.println(clazzName4);
    }



}

测试在mysql中存储数据：postman或者浏览器中输入： localhost:9980/test/saveUser/xxm/89

测试在redis中存储数据：postman或者浏览器中输入：http://localhost:9980/test/set/558/666

我这边通过rdm工具可以看到redis中数据：

 

 

 

 

 

 

 

 

 

 

springmvc+redis+mysql（数据库连接简单实现）数据缓存
08-09
实现redis与springmvc配置，数据库连接简单实现，待完善实现连接池
SpringBoot+Jpa+MySql学习
weixin_34185364的博客
04-07 191
上一篇介绍了springboot简单整合mybatis的教程。这一篇是介绍springboot简单整合jpa的教程。 由于jpa的功能强大，后续会继续写关于jpa的介绍已经使用，本文只是简单介绍一下它与springboot的整合。 jpa不需要像mybatis一样创建表，首先给大家看一下application.properties文件代码，其中包含了jpa的配置和数据库配置，尤其注意一下sprin...
Idea + Maven + SpringBoot 搭建项目
weixin_39766941的博客
05-06 313
1.springboot是什么？ springboot 简化spring和xml、properties文件中的配置，继承springboot-parent-Pom文件避免包冲突和简化依赖配置。 2.运行操作： 新建maven项目 - springboot依赖添加Pom文件中 - 编写启动类 - 运行 3.新建maven工程 - 选择maven-archetype-webapp - 新建ja...
Spring Boot整合JPA+MySQL+Redis（一）
IceCaptain的博客
01-29 6627
Spring Boot整合JPA+MySQL+Redis 在开始之前，我们在pom.xml添入关键依赖： JPA依赖： dependency&gt; groupId&gt;org.springframework.bootgroupId&gt; artifactId&gt;spring-boot-starter-data-jpaartifactId&gt; dependency&gt; MySQL依赖：
redis mysql 整合demo_SpringBoot整合MyBatis并使用Redis作为缓存组件的Demo
weixin_33289151的博客
01-27 203
本博客 猫叔的博客，转载请申明出处安装流程1、安装docker & redis如果不清楚docker是什么，请查看docker的文档和简介，这里给出docker的安装过程1.1 安装虚拟机(如果有远程服务器的，请略过此步骤)本文推荐VMvare，尽管vmvare比较臃肿，但是对于新手比较友好，配置很简单从官网下载VMvare，官网地址：https://www.vmware.com/cn.h...
Springboot+mybaits+mysql+redis+nginx，仓库管理系统。毕业设计
02-20
"Springboot+mybaits+mysql+redis+nginx，仓库管理系统。毕业设计" 这个标题揭示了这个项目的核心技术栈和应用领域。它表明了一个基于Spring Boot框架的仓库管理系统，该系统集成了MyBatis作为持久层框架，MySQL作为...
springBoot+mysql+redis基础项目
10-29
【标题】"springBoot+mysql+redis基础项目"是一个适合初学者入门的IT项目，它结合了Spring Boot、MySQL和Redis三个关键组件，构建了一个基本的后端数据处理框架。这个项目的核心目标是帮助新手理解如何在实际开发中...
SpringBoot+JPA+MySQL+Swagger+Redis实现CRUD
04-04
在本项目中，我们利用了SpringBoot框架，联合JPA（Java Persistence API）与MySQL数据库，以及Swagger和Redis，来构建一个完整的CRUD（Create、Read、Update、Delete）应用程序。下面将详细介绍这些技术及其在项目中...
springboot+mysql+redis集成Demo
11-15
在本项目"springboot+mysql+redis集成Demo"中，我们将探讨如何将Spring Boot框架与MySQL数据库和Redis缓存服务进行整合，以实现一个高效、可扩展的应用程序。以下是对这个集成过程的关键知识点的详细说明。 1. **...
商城管理系统-vue+springboot+redis
06-22
开发者可以利用Spring Data JPA进行持久层操作，与MySQL等关系型数据库进行交互，同时Spring Security可实现权限控制，确保系统安全。Spring Boot还支持Actuator监控应用运行状态，便于故障排查和性能优化。 再者，...
Redis+mysql整合spring的Demo
04-07
redis使用例子，包含增删改査
springboot项目连接数据库及redis实例
01-23
使用springboot搭建，连接mysql数据库以及redis缓存。需要修改数据库和redis配置才能正常运行。
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制
10-17
Shiro + JWT + SpringBoot + MySQL + Redis(Jedis)实现无状态鉴权机制(Restful风格API)(改为数据库形式(MySQL)) 博客源码 附件
springboot+jpa+mysql+redis+swagger整合步骤
weixin_30408309的博客
09-15 181
springboot+jpa+MySQL+swagger框架搭建好之上再整合redis： 在电脑上先安装redis： 一、在pom.xml中引入redis 二、在application.yml里配置redis，单独说明：redis刚一开始安装好是没有设置密码的。否则，会报connection错误。 三、在service配置Redis，需要说明的在方法前配置@Cacheable中只有...
SpringBoot2.0.4使用JPA和Redis
zab635590867的博客
08-21 3210
      近来研究SpringBoot持久化与缓存的问题，搜集资料做了一个Demo。       环境：Win10、JDK1.8、IDEA、Redis、Mysql5.7、Redis3.2、SpringBoot2.0.4Release版 第一步建立一个学生表： CREATE TABLE `student` ( `sid` int(11) DEFAULT NULL, `sname` ...
使用java8 springBoot mysql mybatis redies nacos 技术，写一个学生管理系统网站，请用代码实现它
weixin_35756892的博客
01-01 157
用 Java 8、Spring Boot、MySQL、Mybatis、Redis 和 Nacos 技术写一个学生管理系统的网站的步骤大致如下： 创建一个 Spring Boot 项目。 在项目中配置 MySQL 数据库连接。 在项目中使用 Mybatis 访问 MySQL 数据库。 在项目中使用 Redis 进行缓存。 使用 Nacos 进行服务注册和发现。 创建学生管理系统的相关数据...
spring redis mysql_使用Springboot整合redis与mysql
weixin_33835368的博客
01-30 363
package com.ckf.springboot_mysql_redis.controller;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.ckf.springboot_mysql_...
Docker部署SpringBoot项目并连接MySQL、Redis
流星泪
05-05 1239
Docker部署SpringBoot项目并连接MySQL、Redis服务器域名绑定安装docker安装tomcat安装MySQL安装Redis部署SpringBoot项目 服务器域名绑定 新买的腾讯云服务器，如果绑定新买的域名？这里有3个前置步骤：买服务器，买域名，备案。这三个步骤就不一一说了。 服务器绑定域名，换种说法就是域名解析的时候解析到你这台服务器上。操作步骤如下 点击“前往设置”来设置解析规则 在域名列表中选择你想绑定到服务器的域名，点后边的“解析” 第三步也就是最后一步，添加解析规则 点
SpringBoot+Spring+JPA+Redis+MySql+Swagger 博客系统 Day1
心猿意码
03-01 540
功能设计 代码结构 Swagger 文档 Maven Pom文件 <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 ht...
springboot+echarts+redis数据分析可视化系统源码
- 在Spring Boot项目中，可以利用Spring Data JPA或者MyBatis等技术与MySQL进行交互，完成数据的CRUD(创建、读取、更新、删除)操作。 - 数据库设计包括表结构设计、索引优化、事务管理等，是保证数据存储效率和...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值