springCloud+Vue改造品优购第四章-------缓存服务搭建

最新推荐文章于 2023-11-01 23:04:17 发布
最新推荐文章于 2023-11-01 23:04:17 发布
阅读量651 收藏
点赞数 1
分类专栏： 品优购改造系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiqiang2/article/details/82119388
版权

最终缓存API效果展示
这里写图片描述

缓存服务注册
这里写图片描述

第一步 创建工程，编写pom.xml

<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>
  <groupId>com.wq.cache</groupId>
  <artifactId>wq-cache</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>wq-cache</name>
  <description>缓存服务</description>

  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>

        <swagger2.version>2.6.1</swagger2.version>
    </properties>

    <dependencies>
        <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>
        <!-- API文档 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${swagger2.version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${swagger2.version}</version>
        </dependency>
        <!-- API文档 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 注册中心 -->
        <!-- actuator监控信息完善 -->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Dalston.SR3</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- 将微服务provider侧注册进eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.3.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
            <version>1.3.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

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

</project>

第二步 编写配置文件application.yml

#缓存服务
server:
  port: 1001
  context-path: /wq-cache



#redis配置
spring:
  redis:
    database: 0 #用16个库中索引为0的库
    host: 127.0.0.1 #redis服务器的主机IP
    port: 6379      #redis的端口
    password:       #密码,默认为空
    timeout: 1000   #连接超时时间,单位为毫秒
    pool:
      max-active: 200   #连接池的最大连接数,当为负数的时候表示没有限制
      max-wait: -1      #连接池的最大阻塞等待时间,为负数的时候表示没有限制
      max-idle: 10      #连接池的最大空闲连接
      min-idle: 0       #连接池的最小的空闲连接
  #spring应用配置
  application:
    name: wq-cache

#eureka配置
eureka:
  client:
    service-url:
      defaultZone:  http://eureka7001.com:7001/eureka
  instance:
    instance-id: wq-cache
    prefer-ip-address: true

#应用详细信息
info:
  app.name: wq-cache
  app.author: wei-qiang
  app.date: 2018-08-27 21:00:00

第三步 swagger的配置

package com.wq.cache.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

@Configuration
public class Swagger2Config {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.wq.cache.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("缓存服务API文档")
                .description("简单优雅的restfun风格")
                .termsOfServiceUrl("http://localhost:1001/wq-cache/swagger-ui.html")
                .version("1.0")
                .build();
    }


}

第四步 redis配置

package com.wq.cache.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wq.cache.util.RedisUtils;

/**
 *author:       wq
 *datetime:     2018年8月27日  下午12:38:39
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  Redis配置类
 *
 */
@Configuration
@EnableCaching
public class RedisConfig {
    private Logger logger = LoggerFactory.getLogger(RedisUtils.class);

    @Bean
    public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(factory);

        @SuppressWarnings({ "rawtypes", "unchecked" })
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //hash类型的key序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        //value序列化方式jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        logger.info("注入redisTemplate:"+redisTemplate);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public RedisUtils redisUtils(RedisTemplate<String, Object> redisTemplate){
        RedisUtils utils = new RedisUtils();
        utils.setRedisTemplate(redisTemplate);
        logger.info("注入RedisUtils:"+utils);
        return utils;
    }
}

第五步 RedisUtil工具类

package com.wq.cache.util;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
/**
 *author:       wq
 *datetime:     2018年8月27日  下午12:38:39
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  
 *
 */
public class RedisUtils {

    private Logger logger = LoggerFactory.getLogger(RedisUtils.class);

    private  RedisTemplate<String, Object> redisTemplate;

    public  RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }

    public  void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    //---------------------------------------------------时间设置/删除方法--------------------------------------------------------
    /**
     * 根据Key指定缓存失效的时间
     * @param key
     * @param time  失效时间,单位:毫秒
     * @return
     */
    public boolean expire(String key, long time){
        try{
            if(time >0){
                this.redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
        }catch(Exception e){
            e.printStackTrace();
            logger.error("redis设置 "+key+" 的缓存时间失败..."+e.getMessage());
            return false;
        }
        return true;
    }

    /**
     * 根据key获取指定的缓存时间
     * @param key
     * @return  返回 0 代表长期有效, 返回 -1 表示获取失败
     */
    public long getExpire(String key){
        if(key.trim() != null && key.trim() != "" ){
            return -1;
        }
        try {
             return this.redisTemplate.getExpire(key);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis获取"+key+" 的缓存时间失败..."+e.getMessage());
            return -1;
        }
    }

    /**
     * 判断key是否存在
     * @param key
     * @return 存在返回true,不存在则返回false
     */
    public boolean hasKey(String key){
        try {
            return this.redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis判断"+key+" 是否存在失败..."+e.getMessage());
            return false;
        }
    }

    /**
     * 根据传来的key删除缓存,可以是一个key,也可以十多个
     * @param key 
     */
    @SuppressWarnings("unchecked")
    public boolean del(String...keys){
        try {
            if(keys.length > 0){
                if(keys.length == 1){
                    this.redisTemplate.delete(keys[0]);
                    return true;
                }else{
                    this.redisTemplate.delete(CollectionUtils.arrayToList(keys));
                    return true;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis删除"+keys+" 失败..."+e.getMessage());
            return false;
        }
        return false;
    }


    //--------------------------------------------------String类型的操作------------------------------------------------------------
    /**
     * 获取缓存
     * @param key
     * @return  当key为空的时候返回null
     */
    public Object get(String key){
        try {
            return key == null ? null : this.redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis获取"+key+" 的值失败..."+e.getMessage());
            return null;
        }
    }


    /**
     * 普通设置缓存值 String<->Object
     * @param key   键
     * @param value 值
     */
    public boolean set(String key, Object value){
        try {
            this.redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis设置值失败..."+e.getMessage());
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键 String
     * @param value 值   Object
     * @param time  毫秒数  缓存时间
     * @return
     */
    public boolean set(String key, Object value, long time){
        try {
            this.redisTemplate.opsForValue().set(key, value, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis设置 "+key+" 值失败..."+e.getMessage());
            return false;
        }
    }

    /**
     * 递增
     * 
     * @param key
     *            键
     * @param delta
     *            要增加几(大于0)
     * @return 失败返回 -1 成功返回增加之后的值
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        try {
            return redisTemplate.opsForValue().increment(key, delta);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis递增 "+key+" 值失败..."+e.getMessage());
            return -1;
        }
    }

    /**
     * 递减
     * 
     * @param key
     *            键
     * @param delta
     *            要减少几(小于0)
     * @return  成功返回递减之后的值,失败返回 -1
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        try {
            return redisTemplate.opsForValue().increment(key, -delta);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis递减 "+key+" 值失败..."+e.getMessage());
            return -1;
        }
    }


    //----------------------------------------------------Map类型的操作-----------------------------------------------------------
    /**
     * HashGet
     * 
     * @param key
     *            键 不能为null
     * @param item
     *            项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        if(key == "" || key == null){
            throw new RuntimeException("Key不能为null...");
        }
        if(item == "" || item == null){
            throw new RuntimeException("item不能为null...");
        }
        try {
            return redisTemplate.opsForHash().get(key, item);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis获取 "+key+"---"+item+"值失败..."+e.getMessage());
            return null;
        }
    }

    /**
     * HashSet
     * 
     * @param key
     *            键
     * @param map
     *            对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("redis设置 "+key+"---"+map+"值失败..."+e.getMessage());
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * 
     * @param key
     *            键
     * @param map
     *            对应多个键值
     * @param time
     *            时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param value
     *            值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param value
     *            值
     * @param time
     *            时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * 
     * @param key
     *            键 不能为null
     * @param item
     *            项 可以使多个 不能为null
     */
    public boolean hdel(String key, Object... item) {
        try {
            redisTemplate.opsForHash().delete(key, item);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 判断hash表中是否有该项的值
     * 
     * @param key
     *            键 不能为null
     * @param item
     *            项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        try {
            return redisTemplate.opsForHash().hasKey(key, item);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param by
     *            要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * 
     * @param key
     *            键
     * @param item
     *            项
     * @param by
     *            要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        try {
            return redisTemplate.opsForHash().increment(key, item, -by);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ============================set=============================
    /**
     * 根据key获取Set中的所有值
     * 
     * @param key
     *            键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * 
     * @param key
     *            键
     * @param values
     *            值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * 
     * @param key
     *            键
     * @param time
     *            时间(秒)
     * @param values
     *            值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * 
     * @param key
     *            键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * 
     * @param key
     *            键
     * @param values
     *            值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ===============================list=================================
    /**
     * 获取list缓存的内容
     * 
     * @param key
     *            键
     * @param start
     *            开始
     * @param end
     *            结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * 
     * @param key
     *            键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * 
     * @param key
     *            键
     * @param index
     *            索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * 
     * @param key
     *            键
     * @param value
     *            值
     * @param time
     *            时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * 
     * @param key
     *            键
     * @param index
     *            索引
     * @param value
     *            值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * 
     * @param key
     *            键
     * @param count
     *            移除多少个
     * @param value
     *            值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}

第六步 服务层的开发

这里redis存在map，String，List，Set，Hash不同的操作，所以将不同的类型放在不同类中

RedisCommonOperationController

package com.wq.cache.controller.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.wq.cache.util.RedisUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 *author:       wq
 *datetime:     2018年8月27日  下午5:11:26
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  Redis缓存服务 公共API
 *
 */
@Api(value="Redis服务Common类型API")
@RestController
@RequestMapping("/cache/redis/common")
public class RedisCommonOperationController {

    @Autowired
    private RedisUtils redisUtils;

    @ApiOperation(value="根据key设置缓存的过期时间", notes="参数说明:key为键值,time为过期时间")
    @PutMapping("/expire")
    public ResponseEntity<Boolean> expire(@RequestParam(value="key", required=true)String key, 
            @RequestParam(value="time", required=true)long time){
        return ResponseEntity.ok(redisUtils.expire(key, time));
    }

    @ApiOperation(value="根据key获取缓存有效时间", notes="参数说明:key为键值,返回有效时间")
    @GetMapping("/expire-time")
    public ResponseEntity<Long> getExpire(@RequestParam(value="key", required=true)String key){
        return ResponseEntity.ok(redisUtils.getExpire(key));
    }

    @ApiOperation(value="判断key是否存在", notes="参数说明:key为键值,存在返回true,否则false")
    @GetMapping("/exist-key")
    public ResponseEntity<Boolean> hasKey(@RequestParam(value="key", required=true)String key){ 
        return ResponseEntity.ok(redisUtils.hasKey(key));
    }

    @ApiOperation(value="根据key删除缓存", notes="参数说明:keys可以是多个参数")
    @DeleteMapping("/keys")
    public ResponseEntity<Boolean> delKey(@RequestParam(value="keys", required=true)String...keys){ 
        return ResponseEntity.ok(redisUtils.del(keys));
    }

}

RedisListOperationController

package com.wq.cache.controller.redis;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.wq.cache.util.RedisUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 *author:       wq
 *datetime:     2018年8月27日  下午5:11:26
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  Redis缓存服务 Set类型的API
 *
 */
@Api(value="Redis服务List类型API")
@RestController
@RequestMapping("/cache/redis")
public class RedisListOperationController {

    @Autowired
    private RedisUtils redisUtils;

    @ApiOperation(value="将Object放入缓存", 
            notes="参数说明:key->键;value->Object类型的值")
    @PostMapping("/list")
    public ResponseEntity<Boolean> lSet(@RequestParam(value="key", required=true)String key,
            @RequestBody(required = true)Object value){
        return ResponseEntity.ok(redisUtils.lSet(key,value));
    }

    @ApiOperation(value="将Object放入缓存,并设置过期时间", 
            notes="参数说明:key->键;value->Object类型的值;time->过期时间")
    @PostMapping("/list-time")
    public ResponseEntity<Boolean> lSet(@RequestParam(value="key", required=true)String key,
            @RequestBody(required = true)Object value,
            @RequestParam(value="time", required=true)long time){
        return ResponseEntity.ok(redisUtils.lSet(key,value,time));
    }

    @ApiOperation(value="将list放入缓存", 
            notes="参数说明:key->键;value->Object类型的值")
    @PostMapping("/list-list")
    public ResponseEntity<Boolean> lSet(@RequestParam(value="key", required=true)String key,
            @RequestBody(required = true)List<Object> value){
        return ResponseEntity.ok(redisUtils.lSet(key,value));
    }

    @ApiOperation(value="将list放入缓存;并设置过期时间", 
            notes="参数说明:key->键;value->Object类型的值;time:long类型的毫秒数")
    @PostMapping("/list-list-time")
    public ResponseEntity<Boolean> lSet(@RequestParam(value="key", required=true)String key,
            @RequestBody(required = true)List<Object> value,
            @RequestParam(value="time", required=true)long time){
        return ResponseEntity.ok(redisUtils.lSet(key,value,time));
    }

    @ApiOperation(value="移除N个值为value的项", 
            notes="参数说明:key->键;count->个数;value->Object类型的值")
    @DeleteMapping("/list")
    public ResponseEntity<Long> lRemove(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="count", required = true)long count,
            @RequestBody(required = true)Object value){
        return ResponseEntity.ok(redisUtils.lRemove(key,count,value));
    }

    @ApiOperation(value="获取list缓存的内容", 
            notes="参数说明:key->键;start->开始的索引;end->结束的索引;0到-1返回所有值;返回类型List<Object>")
    @GetMapping("/list")
    public ResponseEntity<List<Object>> sDecr(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="start", required = false)long start, 
            @RequestParam(value="end", required = false)long end){
        return ResponseEntity.ok(redisUtils.lGet(key, start, end));
    }

    @ApiOperation(value="通过索引 获取list中的值", 
            notes="参数说明:key->键;index->索引;"
                    + "索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推;返回Object")
    @GetMapping("/list-index")
    public ResponseEntity<Object> lGetIndex(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="index", required = true)long index){
        return ResponseEntity.ok(redisUtils.lGetIndex(key, index));
    }

    @ApiOperation(value="获取list缓存的长度", 
            notes="参数说明:key->键;返回list长度")
    @GetMapping("/list-length")
    public ResponseEntity<Long> lGetListSize(@RequestParam(value="key", required=true)String key){
        return ResponseEntity.ok(redisUtils.lGetListSize(key));
    }


    @ApiOperation(value="根据索引修改list中的某条数据", 
            notes="参数说明:key->键;index->索引;value->Object类型的值")
    @PutMapping("/list")
    public ResponseEntity<Boolean> lUpdateIndex(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="index", required = false)long index,
            @RequestBody(required = true)Object value){
        return ResponseEntity.ok(redisUtils.lUpdateIndex(key,index,value));
    }
}

RedisMapOperationController

package com.wq.cache.controller.redis;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.wq.cache.util.RedisUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 *author:       wq
 *datetime:     2018年8月27日  下午5:11:26
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  Redis缓存服务 Map类型的API
 *
 */
@Api(value="Redis服务List类型API")
@RestController
@RequestMapping("/cache/redis")
public class RedisMapOperationController {

    @Autowired
    private RedisUtils redisUtils;


    //-----------------------------------------------Map类型API---------------------------------------------------------------

    @ApiOperation(value="根据key,item获取Hash类型的值", notes="参数说明:key为String,item为String类型")
    @GetMapping("/map")
    public ResponseEntity<Object> hget(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)String item){
        return ResponseEntity.ok(redisUtils.hget(key,item));
    }

    @ApiOperation(value="根据key,item,设置Hash值为value", notes="参数说明:key为String,map为Map类型")
    @PostMapping("/map-map")
    public ResponseEntity<Boolean> hset(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="map", required=true)Map<String, Object> map){
        return ResponseEntity.ok(redisUtils.hmset(key,map));
    }

    @ApiOperation(value="根据key,item,设置Hash值为value,并设置缓存过期事件", notes="参数说明:key为String,map为Map类型,time为long类型的毫秒")
    @PostMapping("/map-map-time")
    public ResponseEntity<Boolean> hset(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="map", required=true)Map<String, Object> map,
            @RequestParam(value = "time")long time){
        return ResponseEntity.ok(redisUtils.hmset(key,map,time));
    }

    @ApiOperation(value="向一张hash表中放入数据,如果不存在将创建;根据key,item,设置Hash值为value",
            notes="参数说明:key为String,item为String类型,value为Object类型")
    @PostMapping("/map-hash")
    public ResponseEntity<Boolean> hset(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)String item,
            @RequestBody(required = true)Object value){
        return ResponseEntity.ok(redisUtils.hset(key,item,value));
    }

    @ApiOperation(value="向一张hash表中放入数据,如果不存在将创建;"
            + "根据key,item,设置Hash值为value,并设置过期时间", 
            notes="参数说明:key为String,item为String类型,value为Object类型,time为long类型的毫秒;"
                    + "时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间")
    @PostMapping("/map-hash-time")
    public ResponseEntity<Boolean> hset(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)String item,
            @RequestBody(required = true)Object value,
            @RequestParam(value = "time", required = true)long time){
        return ResponseEntity.ok(redisUtils.hset(key,item,value,time));
    }

    @ApiOperation(value="删除hash表中的值;key不能为null", 
            notes="参数说明:key为String,item为Object类型可以是多个item;")
    @DeleteMapping("/map-hash")
    public ResponseEntity<Boolean> hdel(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)Object... item){
        return ResponseEntity.ok(redisUtils.hdel(key,item));
    }

    @ApiOperation(value="判断hash表中是否有该项的值", 
            notes="参数说明:key和item都不能为null")
    @GetMapping("/map-key")
    public ResponseEntity<Boolean> hHasKey(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)String item){
        return ResponseEntity.ok(redisUtils.hHasKey(key,item));
    }

    @ApiOperation(value="hash递增 如果不存在,就会创建一个 并把新增后的值返回", 
            notes="参数说明:key->捡;item->项;by->增加多少;返回增加后的值")
    @PutMapping("/map-adjunction")
    public ResponseEntity<Double> hHasIncr(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)String item,
            @RequestParam(value="by", required=true)double by){
        return ResponseEntity.ok(redisUtils.hincr(key,item,by));
    }

    @ApiOperation(value="hash递减 如果不存在,就会创建一个 并把较少后的值返回", 
            notes="参数说明:key->捡;item->项;by->增加多少;返回增加后的值")
    @PutMapping("/map-reduction")
    public ResponseEntity<Double> hDecr(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="item", required=true)String item,
            @RequestParam(value="by", required=true)double by){
        return ResponseEntity.ok(redisUtils.hdecr(key,item,by));
    }


}

RedisSetOperationController

package com.wq.cache.controller.redis;

import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.wq.cache.util.RedisUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 *author:       wq
 *datetime:     2018年8月27日  下午5:11:26
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  Redis缓存服务 Set类型的API
 *
 */
@Api(value="Redis服务Set类型API")
@RestController
@RequestMapping("/cache/redis")
public class RedisSetOperationController {

    @Autowired
    private RedisUtils redisUtils;

    @ApiOperation(value="根据key获取Set中的所有值", 
            notes="参数说明:key->键;返回类型Set<Object>")
    @GetMapping("/set")
    public ResponseEntity<Set<Object>> sDecr(@RequestParam(value="key", required=true)String key){
        return ResponseEntity.ok(redisUtils.sGet(key));
    }

    @ApiOperation(value="将数据放入set缓存,并设置时间", 
            notes="参数说明:key->键;values->每一项的值;返回成功放入的个数")
    @PostMapping("/set")
    public ResponseEntity<Long> sSet(@RequestParam(value="key", required=true)String key,
            @RequestBody(required=true)Object... values){
        return ResponseEntity.ok(redisUtils.sSet(key,values));
    }

    @ApiOperation(value="将数据放入set缓存,并设置过期时间", 
            notes="参数说明:key->键;values->每一项的值;time->long类型的过期时间;返回成功放入的个数")
    @PostMapping("/set-time")
    public ResponseEntity<Long> sSet(@RequestParam(value="key", required=true)String key,
            @RequestParam(value="key", required=true)long time,
            @RequestBody(required=true)Object... values){
        return ResponseEntity.ok(redisUtils.sSet(key,values,time));
    }

    @ApiOperation(value="移除值为value的项", 
            notes="参数说明:key->键;values->每一项的值,可以为多个值;返回成功移除的个数")
    @DeleteMapping("/set")
    public ResponseEntity<Long> setRemove(@RequestParam(value="key", required=true)String key,
            @RequestBody(required=true)Object... values){
        return ResponseEntity.ok(redisUtils.setRemove(key,values));
    }

    @ApiOperation(value="根据value从一个set中查询,是否存在", 
            notes="参数说明:key->键;value->值")
    @GetMapping("/set-key")
    public ResponseEntity<Boolean> hHasKey(@RequestParam(value="key", required=true)String key,
            @RequestBody(required=true)Object value){
        return ResponseEntity.ok(redisUtils.sHasKey(key, value));
    }

    @ApiOperation(value="获取set缓存的长度", 
            notes="参数说明:key->键;返回key长度")
    @GetMapping("/set-key-length")
    public ResponseEntity<Long> sGetSetSize(@RequestParam(value="key", required=true)String key){
        return ResponseEntity.ok(redisUtils.sGetSetSize(key));
    }
}

RedisStringOperationController

package com.wq.cache.controller.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.wq.cache.util.RedisUtils;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

/**
 *author:       wq
 *datetime:     2018年8月27日  下午5:11:26
 *E-mail:       1432114216@qq.com
 *blog:         https://blog.csdn.net/weiqiang2
 *Description:  Redis缓存服务 Set类型的API
 *
 */
@Api(value="Redis服务List类型API")
@RestController
@RequestMapping("/cache/redis")
public class RedisStringOperationController {

    @Autowired
    private RedisUtils redisUtils;

    //-----------------------------------------String类型API--------------------------------------------------------------
        @ApiOperation(value="根据key获取缓存", notes="参数说明:key为键,返回Object类型value")
        @GetMapping("/string")
        public ResponseEntity<Object> get(@RequestParam(value="key", required=true)String key){ 
            return ResponseEntity.ok(redisUtils.get(key));
        }

        @ApiOperation(value="根据key和value设置缓存", notes="参数说明:key为String,value为Object类型")
        @PostMapping("/string")
        public ResponseEntity<Boolean> set(@RequestParam(value="key", required=true)String key,
                @RequestBody(required = true) Object value){ 
            return ResponseEntity.ok(redisUtils.set(key,value));
        }

        @ApiOperation(value="根据key,value,time设置缓存,并设置过期时间", notes="参数说明:key为String,value为Object类型,time为long类型的毫秒数")
        @PostMapping("/string-time")
        public ResponseEntity<Boolean> set(@RequestParam(value="key", required=true)String key,
                @RequestParam(value="time", required=true)long time,
                @RequestBody(required = true) Object value){ 
            return ResponseEntity.ok(redisUtils.set(key,value,time));
        }

        @ApiOperation(value="根据key,delta递增", notes="参数说明:key为String,delta为long类型且不必须大于0")
        @PutMapping("/string-adjunction")
        public ResponseEntity<Long> incre(@RequestParam(value="key", required=true)String key,
                @RequestParam(value="delta", required=true)long delta){
            return ResponseEntity.ok(redisUtils.incr(key,delta));
        }

        @ApiOperation(value="根据key,delta递减", notes="参数说明:key为String,delta为long类型且不必须大于0")
        @PutMapping("/string-reduction")
        public ResponseEntity<Long> decr(@RequestParam(value="key", required=true)String key,
                @RequestParam(value="delta", required=true)long delta){
            return ResponseEntity.ok(redisUtils.decr(key,delta));
        }
}

github传送门

weiqiang2
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java简历2年经验编写教程+面试题
weixin_45934981的博客
04-17 1万+
这些项目我都没有写过，我只是答示例教你想，你要有这样的想法，这个项目世界到底有什么，比如图书馆里系统{分类、国籍、材质、价格、新旧、存储仓库、采购地址、退回地址、霉变处理、员工管理、书架材料、楼层管理.....}就是这么个意思，你一样要全部都会吗？项目名字换了，比如换成 城市环境监控平台的，你把你的图书管理模块换成你的农药管理模块这不就高大上了；该项目是一个监控人工造林，集成防火防灾等一体综合监管平台，有主要模板有人工植树、防火管理、防虫管理、土地管理、检验管理、施肥管理、人员管理、防盗管理、、、、、
uni-app+Vue3+pinia+uview-plus搭建的项目包
12-28
uni-app+Vue3+pinia+uview-plus搭建的项目包！uni-app+Vue3+pinia+uview-plus搭建的项目包！uni-app+Vue3+pinia+uview-plus搭建的项目包！uni-app+Vue3+pinia+uview-plus搭建的项目包！uni-app+Vue3+pinia+uview-...
白嫖版-2020H马javaEE2.1就业课程
qq_14958051的博客
09-12 1409
来源：视频资源来自网络如有侵权请告知删除就业班2.1笔记源码资料-压缩版阶段1：会员版(2.1)-Java基础和进阶阶段2：会员版(2.0)-javaWeb阶段3：会员版(2...
白嫖版-2020H马javaEE2.1就业课程企业级
java思维导图
11-16 572
来源：视频资源来自网络如有侵权请告知删除就业班2.1笔记源码资料-压缩版阶段1：会员版(2.1)-Java基础和进阶阶段2：会员版(2.0)-javaWeb阶段3：会员版(2...
JavaEE就业课 V12.5 完整版
11-01 481
众所周知，在IT互联网领域是靠技术吃饭的，更符合企业需求的先进技术才是硬通货。黑马Java学科一直在行动，一直走在行业最前沿!四项目制用四个不同类型、不同开发深度的项目，去解决企业用人需求与学员具备相应开发能力匹配的问题沉浸式场景化实战还原学员进入企业后错综复杂的真实工作场景，使学员在学知识积累经验的同时，真正了解企业实际工作中的各种实际情况分层次教学区别于同行一锅烩的教学方法，将知识点科学分为实用篇、高级篇、面试篇，分层次解决不同学习阶段吸收问题。
程序员最关注的三大话题，第二个不信你不看
weixin_51689029的博客
04-15 1217
“程序员的薪资很高，是真的吗？” “用我们的一句话来说，我一年纳的税比你的工资还多，就是这么低调！” 近日，网上一则关于“听说程序员薪资很高是真的吗？”的视频，吸引了不少热心群众的围观。 他们大多是这样式的： 明里吐槽“程序员是吃青春饭的，还会掉头发……” 暗里羡慕“薪资也太高了吧！我什么时候能拿这么高的薪资……” 程序员真的是这样吗？ 是时候告诉你们真相了！ 程序员的收入真相？ 有人欢喜有人忧 有网络的地方就有江湖，有江湖的地方就有程序员。对于程序员的薪资，网友有话说： 凡尔赛型网友： 我在长沙月薪才1
00后最关注的职业：公务员排第二！第一是？
weixin_51689029的博客
10-27 877
每个时代都会塑造出不同的优秀人才，00后这一代，是充满个性和力量的一代，他们正在以自己的方式快速成长，适应社会。 没有哪一代人是没有压力、过得很容易的，只有不惧挑战、迎难而上，才是每一代人必须要做的事情。当下，IT互联网行业就业机会多、薪资高，java、前端、Python+大数据开发、人工智能、软件测试、新媒体运营、UI设计均为当下互联网热门刚需岗位，帮助无数小伙伴找到了自己满意的高薪工作。 无论你是刚毕业的应届生，还是处在迷茫期想要转行的职场人，大可看看下面几个学科的学习路线有没有适合自己的，
连续10年霸榜第一？程序员「最常用」的编程语言是它？
weixin_51689029的博客
06-29 1181
近日，StackOverflow 发布了《2022年度开发者调查报告》，了解的程序员朋友们应该知道，StackOverflow 年度开发者调查，是面向全球开发者进行的规模最大、最全面的一次调查。本次调查涉及全球 180 个国家和地区的开发人员，报告涵盖了当下流行的技术，操作系统、云平台、数据库状况等内容。摘录了一些报告中的精彩部分，一起来看看吧 最流行的语言：JavaScript 持续霸榜 报告显示，在所有受访者与专业开发者的调查中，JavaScript 连续十年成为最常用的编程语言。另外 TypeScri
java ee会员功能项目_黑马javaEE 2020年会员版2.1就业课程240G带文档资料源码
weixin_39761880的博客
02-16 786
├─1-04 就业课(2.1)-面向对象-继承-多态││├─第1节 继承││├─第2节 多态││├─第3节 接口││└─第4节 内部类” g7 x” m8 j2 |││5 g” {v4 v; C( s. C1 b│├─1-05 就业课(2.1)-常用API第二部分& V% y9 l” c6 F& {: C. i: W8 @││├─...
4月编程排行榜出啦~速看新变化~
weixin_51689029的博客
04-18 4104
程序员都关心的Tiobe编程语言排行榜新鲜出炉啦！4月的排行有什么变化呢？快跟着小编一起看看： Tiobe编程排行榜前20名 Tiobe编程排行榜Top 10趋势 素材来源：https://www.tiobe.com/tiobe-index/，如侵删 Tiobe编程排行榜依据谷歌、雅虎、维基百科、亚马逊等流行搜索引擎得出计算评级，是编程语言流行度的一个指标，每月更新一次，现在已经成为程序员判定某种编程语言是否流行的重要指标之一，也是企业在构建新软件系统时选择哪种编程语言的重要战略决策参考之一。 而在如此
youlai-mall: Spring Cloud + vue3 + uni-app 微服务商城项目
05-04
youlai-mall 是【有来开源组织】基于Spring Boot、Spring Cloud & Alibaba 、Vue3、Element-Plus、uni-app等全栈主流技术栈构建的开源商城项目，涉及后端微服务、 前端管理、 微信小程序和 APP应用等多端的开发。...
SpringCloud + Vue 微服务项目-springcloud-vue-project.zip
01-29
4. 路由管理：Vue.js的router模块进行页面路由管理，SpringCloud API Gateway处理不同服务的路由规则。 5. 实时通讯：通过WebSocket实现前后端的实时通信，例如SpringCloud的Sleuth模块可以配合Zipkin实现服务追踪...
SpringCloud+vue+uniapp智慧物联/物业/巡检/停车管理系统源码
05-08
基于SpringCloud微服务、分布式架构，更易扩展；项目前后端分离，后端使用JAVA，前端VUE，Uni-app框架；MySQL、Redis多种数据存储方式，只为更快；ActiveMq订阅消息队列，让订单更快流转。 二、项目应用多端 管理...
在线考试系统，采用SpringCloud+Vue3.zip
12-29
在线考试系统，采用SpringCloud+Vue3，完成遗传算法自动组卷、文本批量导入题目、班级码。完成课程、考试、题库、试卷、考试、班级相关功能， 前端：Vue 3、Vite、Pinia、Arco UI，Echarts 后端：SpringBoot、S…....
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
MySQL查询加速器：利用Query Cache提升效率
07-31
MySQL是一个流行的开源关系型数据库管理系统（RDBMS），广泛用于Web应用程序的后端数据存储。它基于结构化查询语言（SQL）来管理数据，并且是LAMP（Linux, Apache, MySQL, PHP/Python/Perl）技术栈的一部分，这个技术栈常用于构建动态网站和Web应用程序。 MySQL的特点包括： - **开放源代码**：MySQL的源代码是公开的，任何人都可以自由使用和修改。 - **跨平台**：MySQL可以在多种操作系统上运行，包括Linux、Windows、macOS等。 - **高性能**：MySQL以其快速的查询处理和良好的性能而闻名。 - **可靠性**：MySQL提供了多种机制来确保数据的完整性和可靠性，包括事务支持、备份和恢复功能。 - **易于使用**：MySQL提供了简单直观的界面和丰富的文档，便于用户学习和使用。 - **可扩展性**：MySQL支持从小型应用到大型企业级应用的扩展。 - **社区支持**：由于其广泛的使用，MySQL拥有一个活跃的开发者社区，提供大量的资源和支持。 MySQL被广泛应用于各种场景，包括在线事务处理（OL
Objective-C语言的基础教程.md
最新发布
07-31
Objective-C是一种面向对象的编程语言，是C语言的扩展。它主要用于苹果的iOS和macOS应用程序开发。
基于springboot+springcloud+vue前后端分离项目实战 --开篇 cha138.com
05-10
本文介绍了一个基于Spring Boot、Spring Cloud和Vue前后端分离的项目实战。这个项目是一个简单的在线商城，包含了用户注册、登录、商品展示、购物车、订单管理等功能。通过这个项目，读者可以深入理解前后端分离的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值