SpringBoot整合Redis

最新推荐文章于 2021-11-11 12:05:00 发布
最新推荐文章于 2021-11-11 12:05:00 发布
阅读量148 收藏
点赞数
分类专栏： Java技术点整合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43106280/article/details/118597007
版权

添加pom依赖

<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>1.4.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

application.yml配置

spring:
  #reids配置
  redis:
    host: localhost
    port: 6379
    password: 123456
    jedis:
      pool:
        max-active: 8 #连接池最大连接数(使用负值表示没有限制)
        max-wait: -1 #连接池最大阻塞等待时间(使用负值表示没有限制)
        max-idle: 8 #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接
    timeout: 300000 #连接超时时间(毫米)

初始化注入Jedis

package com.xxqy.shopping.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 注入JedisPool
 * @Author: yww
 */
@Configuration
public class RedisConfig{

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private Integer port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.timeout}")
    private Integer timeout;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private Integer maxIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    public static JedisPool jedisPool;//获取jedisPool连接池

    //初始化jedisPool
    @Bean
    public JedisPool JedisPool(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        //连接耗尽时是否阻塞,false报异常,true阻塞直到超时,默认为true
//        jedisPoolConfig.setBlockWhenExhausted(true);
        //是否启用pool的jmx管理功能,默认为true
        JedisPool pool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
        System.out.println("JedisPool注入成功!");
        System.out.println("redis地址: "+host + ":"+port);
        System.out.println(pool);
        jedisPool = pool;
        return pool;
    }
}

编写reids工具类

package com.xxqy.shopping.utils;

import com.xxqy.shopping.config.RedisConfig;
import redis.clients.jedis.Jedis;

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

/**
 * jedis3.0之前使用 jedisPool.returnResource(jedis)关闭连接
 * jedis3.0之后使用 jedis.close()关闭连接
 * redis支持类型:
 *          String(字符串),Hash(哈希),List(列表),Set(集合),Zset(sorted set:有序集合)
 * @Author: yww
 */
public class RedisUtil {

    /**
     * 初始化Jedis连接
     * @param indexDb 选择reids库 0-15
     * @return
     */
    private static Jedis getJedis(int indexDb){
        Jedis jedis =null;
        try{
            if(RedisConfig.jedisPool!=null){
                jedis = RedisConfig.jedisPool.getResource();
                jedis.select(indexDb);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return jedis;
    }


    /**
     * 通过key获取存储redis中的value
     * @param key
     * @return 成功返回value 失败返回null
     */
    public static String get(String key,int indexDb){
        Jedis jedis = null;
        String value = null;
        try{
            jedis = getJedis(indexDb);
            value = jedis.get(key);
        }finally{
            assert jedis != null;//assert断言 ,jedis为空则异常,不为空就继续进行
            jedis.close();//关闭jedis连接
        }
        return value;
    }

    /**
     * 通过key获取存储在reids中的value
     * @param key
     * @param indexDb 选择reids库 0-15
     * @return 成功返回value 失败返回null
     */
    public static byte[] get(byte[] key,int indexDb){
        Jedis jedis = null;
        byte[] value = null;
        try{
            jedis = getJedis(indexDb);
            value = jedis.get(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
        return value;
    }

    /**
     * 向redis存入key和value,并释放连接资源
     * @param key
     * @param value
     * @param indexDb 选择reids库 0-15
     * @return 成功返回OK
     */
    public static String set(String key,String value,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.set(key,value);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 向redis存入key和value,并释放连接资源
     * @param key
     * @param value
     * @param indexDb
     * @return 成功返回OK
     */
    public static String set(byte[] key,byte[] value,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.set(key,value);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 删除指定的key,也可以传入一个包含key的数组
     * @param indexDb
     * @param keys 一个key或多个
     * @return 返回删除成功的个数
     */
    public static Long del(int indexDb, String... keys){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.del(keys);
        }finally{
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key向指定的value追加值
     * @param key
     * @param str
     * @param indexDb
     * @return 成功返回 追加后value的长度
     */
    public static Long append(String key,String str,int indexDb) {
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.append(key,str);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 判断key是否存在
     * @param key
     * @param indexDb redis库 0-15
     * @return true Or false
     */
    public static Boolean exists(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.exists(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 清空当前数据库中所有的key,此命令从不失败
     * @param indexDb
     * @return 返回OK
     */
    public static String flushDb(int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.flushDB();
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 以秒为单位,返回该 key 的剩余生存时间
     * @param key
     * @param indexDb
     * @return 当key不存在时,返回 -2, 当key存在但没有设置剩余生存时间时,返回 -1, 否则,以秒为单位,返回key的剩余生存时间, 异常返回 0
     */
    public static Long ttl(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.ttl(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 移出该 key 的生存时间 ,将这个key 从 [易失的](带生存时间的key)转换成[持久的](一个不带生存时间,永不过期的key)
     * @param key
     * @param indexDb
     * @return
     */
    public static Long persist(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.persist(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 新增key,指定过期时间(秒),如果key已存在,将会替换旧值
     * @param key
     * @param seconds 秒
     * @param value
     * @param indexDb
     * @return 设置成功返回OK,当seconds参数不合法时,返回错误
     */
    public static String setex(String key,int seconds,String value,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.setex(key,seconds,value);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * key不存在就设置,key存在的情况下,不操作reids内存,返回0,
     * @param key
     * @param value
     * @param indexDb
     * @return
     */
    public static Long setnx(String key,String value,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.setnx(key,value);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过批量的key获取批量的value
     * @param indexDb
     * @param keys
     * @return
     */
    public static List<String> mget(int indexDb, String... keys){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.mget(keys);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 批量设置key:value,也可以一个
     * 示例:
     *  RedisUtil.mset(new String[]{"key1","value1","key2","value2"})
     * @param indexDb
     * @param keysvalues
     * @return 成功返回OK 失败/异常 返回 null
     */
    public static String mset(int indexDb,String... keysvalues){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.mset(keysvalues);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key对value进行加值+1操作,当value不是int类型时会返回错误,当key不存在则value为1
     * @param key
     * @param indexDb
     * @return
     */
    public static Long incr(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.incr(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key给指定的value加值,如果key不存在,则value为该值
     * @param key
     * @param number
     * @param indexDb
     * @return
     */
    public static Long incrBy(String key,Long number,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.incrBy(key,number);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 对key的值做减减操作,如果key不存在,则设置key为-1
     * @param key
     * @param indexDb
     * @return
     */
    public static Long decr(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.decr(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key减去指定的value
     * @param key
     * @param number
     * @param indexDb
     * @return
     */
    public static Long decrBy(String key,Long number,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.decrBy(key,number);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key获取value值的长度
     * @param key
     * @param indexDb
     * @return 失败返回null
     */
    public static Long strlen(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.strlen(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key给field设置指定的值,如果key不存在,则先创建
     * @param key
     * @param field
     * @param value
     * @param indexDb
     * @return 如果存在返回0,异常返回null
     */
    public static Long hset(String key,String field,String value,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hset(key,field,value);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key同时设置 hash的多个field
     * @param key
     * @param hash
     * @param indexDb
     * @return 返回OK 异常返回null
     */
    public static String hmset(String key, Map<String,String> hash, int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hmset(key,hash);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key和field获取指定的value
     * @param key
     * @param field
     * @param indexDb
     * @return 没有返回null
     */
    public static String hget(String key,String field,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hget(key,field);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key和fields获取指定的value,如果没有对应的value则返回null
     * @param key
     * @param indexDb
     * @param fields 可以是一个String,也可以是String 数组
     * @return
     */
    public static List<String> hmget(String key,int indexDb,String... fields){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hmget(key,fields);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key给指定的field的value加上指定的值
     * @param key
     * @param field
     * @param value
     * @param indexDb
     * @return
     */
    public static Long hincrby(String key,String field,Long value,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hincrBy(key,field,value);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key和filed判断是否有指定的value存在
     * @param key
     * @param field
     * @param indexDb
     * @return
     */
    public static Boolean hexists(String key,String field,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hexists(key,field);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key返回field的数量
     * @param key
     * @param indexDb
     * @return
     */
    public static Long hlen(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hlen(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * hash类型:
     *  通过key删除指定的field
     * @param key
     * @param indexDb
     * @param fields 一个或多个field
     * @return
     */
    public static Long hdel(String key,int indexDb,String... fields){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hdel(key,fields);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key返回所有的field
     * @param key
     * @param indexDb
     * @return
     */
    public static Set<String> hkeys(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hkeys(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key返回所有的key和value
     * @param key
     * @param indexDb
     * @return
     */
    public static List<String> hvals(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hvals(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key获取所有的field和value
     * @param key
     * @param indexDb
     * @return
     */
    public static Map<String,String> hgetAll(String key,int indexDb){
        Jedis jedis = null;
        Map<String,String> res = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.hgetAll(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key向指定的set中添加value
     * @param key
     * @param indexDb
     * @param members 可以是String,也可以是String数组
     * @return
     */
    public static Long sadd(String key,int indexDb,String... members){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.sadd(key,members);
        }finally {
            assert  jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key删除set中对应的value值
     * @param key
     * @param indexDb
     * @param members
     * @return
     */
    public static Long srem(String key,int indexDb,String... members){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.srem(key,members);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key判断value是否是set中的元素
     * @param key
     * @param member
     * @param indexDb
     * @return
     */
    public static Boolean sismember(String key,String member,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.sismember(key,member);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }

    /**
     * 通过key获取set中所有的value
     * @param key
     * @param indexDb
     * @return
     */
    public Set<String> smembers(String key,int indexDb){
        Jedis jedis = null;
        try{
            jedis = getJedis(indexDb);
            return jedis.smembers(key);
        }finally {
            assert jedis != null;
            jedis.close();
        }
    }
}

测试使用

	@SysLog("访问登录界面")
	@RequestMapping("/login")
	public String login(){
	    //TODO redis使用
	    RedisUtil.set("name","张三",1);
	    String name = RedisUtil.get("name", 1);
	    System.out.println(name);
	    return "login";
	}

查看结果
reidsManager

老y来了
关注
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
SpringBoot 整合 Redis 本地配置
KiriSoyer
06-13 774
3.配置application.properties文件 4.修改Redis密码 5.配置Bean 6.注入配置类 7.利用Redis Desktop Manager 客户端管理 Redis
Springboot工程整合Redis以及Redis的使用手册【精】
qq_43097201的博客
04-08 470
本文主要介绍的内容有： 1、Redis的基本语法 2、Springboot整合Jedis的操作 3、Springboot整合RedisTemplate Redis的基本类型有五种： string 字符串类型 (最常用) hash 哈希类型（map格式） set 集合类型（不允许重复） zset 有序集合类型（不允许重复） list 列表类型（允许重复） 注意：与关系型数据库存储在硬盘文件上...
Springboot集成redis， Unable to connect to localhost:6379
zhengzhiyong_zzy的博客
06-09 1万+
前言 spring boot，spring cloud， 几年前就听说很火，我虽然工作有几年的，中途有自己搭demo ，但是一直没有很好的去实操，由于家庭原因跳了个槽，现在用的是springboot，分配任务，大致就是从一个单体架构拆分成分布式架构，为了方便共用，Dao层集成一个项目，定时任务集成一个项目，其实就是简单的copy代码，但是这都能出错，呜呜。 解决方式前言一、错误二、解决 你所能做的就是把握今天，自身强大才能从容面对一切。 一、错误 org.springframework.data.redi
SpringBoot 启动运行成功，localhost无法访问连接
热门推荐
qq_42815049的博客
05-19 2万+
SpringBoot 启动运行成功，localhost无法访问连接问题描述问题的排除项目工程代码可能的原因原因的发现和锁定问题的解决 问题描述 本项目是一个物联网项目，技术框架 SpringBoot+Netty+MySql+MybatisPlus+Swagger 今天运行SpringBoot项目过程中，项目代码没有出现报错情况，在SpringBoot初始化成功之后，在web端访问api文档时，出现了无法访问此网站——localhost拒绝连接访问请求。针对这一问题我开始进行排查解决。 问题的排除 对于这
在springboot配置文件中配置了redis 但是还是无法访问到redis地址
名刀的博客
11-11 4803
配置信息如下 这里注意缩进 redis的配置信息应该在spring下面一级 springboot默认的redis地址是localhost的所以会导致明明配置了别的ip地址 但是还是访问的是本机的
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
最新发布
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
**SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
Spring Boot 启动报错: Unable to connect to Redis server: localhost/127.0.0.1
lzf2284466的博客
06-18 1万+
最近在研究学习spring boot聚合框架，自己动手配置过程中遇到如下问题：org.redisson.client.RedisConnectionException: Unable to connect to Redis server: localhost/127.0.0.1:6379； Exception encountered during context initialization - cancelling refresh attempt: org.springframework.context.
SpringBoot基本操作（五）——SpringBoot使用Jedis整合Redis（有demo）
Gabriel的专栏
04-21 986
SpringBoot2.0笔记 （一）SpringBoot基本操作——环境搭建及项目创建（有demo） （二）SpringBoot基本操作——使用IDEA打war包发布及测试 （三）SpringBoot基本操作——SpringBoot整合SpringDataJpa（有demo） （四）SpringBoot基本操作——SpringBoot使用RedisTemplate整合Redis（有demo...
Java秒杀系统实践学习
zjworldtu的博客
05-13 387
Java秒杀系统实践学习 前言 java秒杀系统核心设计到分布式系统方案、系统的极致优化、深入微服务技能、安全策略，希望通过对他的学习能过对他所涉及到的springboot框架体系结构、redis缓存、mybatis等有进一步了解和认知。 项目框架的搭建 项目框架的搭建分为四部分： Spring Boot的环境搭建； 通过idea创建springboot项目，点击File再点击project然后选择Spring initializr,选择next，选择dependencies创建项目，创建如下的目录结构：
Springboot之整合Redis
学习和工作总结，共勉！
02-01 363
Springboot 整合Redis 如何在Centos7中安装Redis可以参看我的另一篇博客：Centos7安装Redis并设置远程访问 统一的application.yml配置文件 spring: redis: # 服务器地址 host: XXX.XXX.XXX.XXX # 端口 默认为6379 port: 6379 # 密码 默认为空 p...
Redis介绍使用及进阶
dingxian9983的博客
04-22 119
目录： 一、介绍 二、缓存问题 三、Redis内存滥用 四、键命名规范 五、Redis使用场景 六、持久化操作 七、.Net Core 使用redis 简单介绍 一、介绍 1、 高性能-- Redis能读的速度是110000次/s,写的速度是81000次/s、c语言实现距离系统更近、数据存储在内存中、采用了epoll，非阻塞I/O, 2、 原子性-- R...
阿里云OCR图片文字识别使用教程
尹文伟的博客
05-17 7834
第一步: 租赁阿里云OCR文字识别服务 第二步: 购买服务后会对应的 appCode 第三步: 使用aliyun提供的接口 package io.renren; import io.renren.utils.HttpUtils; import org.apache.http.HttpResponse; import org.apache.http.util.EntityUtils; import java.util.*; /** * @author yww * @createTime 2021
SpringBoot整合Swagger
尹文伟的博客
11-30 348
一.Swagger 认识Swagger Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。总体目标是使客户端和文件系统作为服务器以同样的速度来更新。文件的方法，参数和模型紧密集成到服务器端的代码，允许API来始终保持同步。 作用： 1. 接口的文档在线自动生成。 2. 功能测试。 Swagger是一组开源项目，其中主要要项目如下： Swagger-tools:提供各种与Swagger进行集成和交互的工具。例如模式检验、Swagger 1.2文档转
SpringBoot整合Log4j2
尹文伟的博客
12-01 290
一.Log4j2日志 log4j2日志级别 在log4j2中,共有8个级别,按照从低到高为: ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF ALL : 最低等级的,用于打开所有日志记录。 Trace : 是追踪,就是程序推进以下。 Debug : 指出细粒度信息事件对调式应用程序是非常有帮助的。 Info : 消息在粗粒度级别上突出强调应用程序的运行过程。 Warn : 输出警告及warn以下级别的日
springboot配置logback日志
尹文伟的博客
06-11 209
日志效果如下：按日期,日志级别记录日志信息 在resources下创建logback-spring.xml文件即可 logback-spring.xml <?xml version="1.0" encoding="UTF-8"?> <!-- 从高到地低 OFF 、 FATAL 、 ERROR 、 WARN 、 INFO 、 DEBUG 、 TRACE 、 ALL --> <!-- 日志输出规则 根据当前ROOT 级别，日志输出时，级别高于root默认的级别时 会输出 -
SpringBoot整合WebSocket
尹文伟的博客
08-13 197
引入依赖 <!--websocket--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 编写配置类 /** * 开启WebSocket支持 * @author: yww * @create..
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值