Spring Boot 学习笔记 11 : Redis

最新推荐文章于 2019-11-02 12:20:44 发布
最新推荐文章于 2019-11-02 12:20:44 发布
阅读量215 收藏
点赞数
分类专栏： springboot 文章标签： spring-boot redis hash exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smileorsilence/article/details/83347854
版权

在 SpringBoot 开发项目的过程中，使用到了 RedisTemplate 操作 Hash，读值时遇到关于类型转换的问题，于是编写了一个小的测试 demo，现在记录下来，以后有时间再深入研究。

  1. 项目结构如下：
    项目结构
    进入项目根目录，使用 tree /f 命令输出目录结构如下：

    ├─src
    │ ├─main
    │ │ ├─java
    │ │ │ └─com
    │ │ │ └─example
    │ │ │ └─demo
    │ │ │ │ SpringBootRedisApplication.java
    │ │ │ │
    │ │ │ ├─config
    │ │ │ │ RedisConfiguration.java
    │ │ │ │
    │ │ │ ├─domain
    │ │ │ │ Permission.java
    │ │ │ │ Role.java
    │ │ │ │ User.java
    │ │ │ │
    │ │ │ └─service
    │ │ │ │ RedisService.java
    │ │ │ │ UserService.java
    │ │ │ │
    │ │ │ └─util
    │ │ │ RedisKey.java
    │ │ │
    │ │ └─resources
    │ │ │ application-dev.yml
    │ │ │ application-prod.yml
    │ │ │ application.yml
    │ │ │
    │ │ ├─static
    │ │ └─templates
    │ └─test
    │ └─java
    │ └─com
    │ └─example
    │ └─demo
    │ │ SpringBootRedisApplicationTests.java
    │ │
    │ └─service
    │ RedisServiceTest.java

  2. pom 文件如下：

    <?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>

	<groupId>com.example</groupId>
	<artifactId>spring-boot-redis</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>spring-boot-redis</name>
	<description>Demo project for Spring Boot Redis</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.6.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>
	</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>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

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


</project>

  3. RedisConfiguration 配置类如下：

    package com.example.demo.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author smileorsilence
 */
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfiguration {

    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
        redisConnectionFactory.setHostName(redisProperties.getHost());
        redisConnectionFactory.setPort(redisProperties.getPort());
        redisConnectionFactory.setDatabase(redisProperties.getDatabase());

        if (this.redisProperties.getPassword() != null)
            redisConnectionFactory.setPassword(redisProperties.getPassword());
        if (this.redisProperties.getTimeout() > 0) redisConnectionFactory.setTimeout(redisProperties.getTimeout());

        return redisConnectionFactory;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JsonRedisSerializer());
        //for hash
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JsonRedisSerializer());
        return redisTemplate;
    }

    public static class JsonRedisSerializer implements RedisSerializer<Object> {
        private ObjectMapper objectMapper = new ObjectMapper();

        public JsonRedisSerializer() {
        }

        @Override
        public byte[] serialize(Object o) throws SerializationException {
            if (o == null) {
                return new byte[0];
            } else {
                try {
                    return this.objectMapper.writeValueAsBytes(o);
                } catch (Exception e) {
                    throw new SerializationException("Could not write JSON: " + e.getMessage());
                }
            }
        }

        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
            if (bytes == null) {
                return null;
            } else {
                try {
                    return this.objectMapper.readValue(bytes, Object.class);
                } catch (Exception e) {
                    throw new SerializationException("Could not read JSON: " + e.getMessage());
                }
            }
        }
    }

}

  4. RedisService 工具类如下：

    package com.example.demo.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

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

/**
 * @author smileorsilence
 */
@Slf4j
@Service
public class RedisService {

    /***** ***** ***** ***** ***** ***** Operation for Key ***** ***** ***** ***** ***** *****/

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    public void deleteKey(String key) {
        log.debug("Delete key in redis, key:{}", key);
        redisTemplate.delete(key);
    }

    public void expireKey(String key, Long times, TimeUnit unit) {
        log.debug("Expire key in redis, key:{}", key);
        redisTemplate.expire(key, times, unit);
    }

    /***** ***** ***** ***** ***** ***** Operation for Value ***** ***** ***** ***** ***** *****/

    public void saveValue(String key, String value) {
        log.debug("Save string into redis, key:{}, value:{}", key, value);
        redisTemplate.opsForValue().set(key, value);
    }

    public void saveObject(String key, Object object) {
        log.debug("Save object into redis, key:{}, value:{}", key, object);
        redisTemplate.opsForValue().set(key, object);
    }

    public Object readObject(String key) {
        log.debug("Read object from redis, key:{}", key);
        return redisTemplate.opsForValue().get(key);
    }

    /***** ***** ***** ***** ***** ***** Operation for List ***** ***** ***** ***** ***** *****/

    public void saveList(String key, List<?> list) {
        log.debug("Save a list into redis, key:{}", key);
        redisTemplate.delete(key);
        for (Object l : list) {
            redisTemplate.opsForList().rightPush(key, l);
        }
    }

    public List<?> readList(String key) {
        log.debug("Read a list from redis, key:{}", key);
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 放入队列的最后一个位置
     */
    public void pushEnd(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 取队列的最后一个元素
     */
    public Object popEnd(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 放入队列的第一个位置
     */
    public void pushFirst(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 取队列的第一个元素
     */
    public Object popFirst(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    /***** ***** ***** ***** ***** ***** Operation for Map ***** ***** ***** ***** ***** *****/

    public void saveMap(String key, Map<?, ?> map) {
        log.debug("Save a map into redis, key:{}", key);
        redisTemplate.delete(key);
        redisTemplate.opsForHash().putAll(key, map);
    }

    public void saveMapValue(String key, String hashKey, Object hashValue) {
        log.debug("Save map value into redis, key:{}, hashKey:{}", key, hashKey);
        redisTemplate.opsForHash().put(key, hashKey, hashValue);
    }

    public void deleteMapValue(String key, String hashKey) {
        log.debug("Delete map value from redis, key:{}, hashKey:{}", key, hashKey);
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    public Map<?, ?> readMap(String key) {
        log.debug("Read a map from redis, key:{}", key);
        return redisTemplate.opsForHash().entries(key);
    }

    public Object readMapValue(String key, String hashKey) {
        log.debug("Read map value from redis, key:{}, hashKey:{}", key, hashKey);
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    public Set<?> readMapKeys(String key) {
        log.debug("Read map keys from redis, key:{}", key);
        return redisTemplate.opsForHash().keys(key);
    }

    public List<?> readMapValues(String key) {
        log.debug("Read map values from redis, key:{}", key);
        return redisTemplate.opsForHash().values(key);
    }

    public boolean hasHashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

}

  5. POJO 类如下：

    package com.example.demo.domain;

import lombok.Data;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * @author smileorsilence
 */
@Data
public class User implements Serializable {

    private Long id;

    private String username;

    private String password;

    private Set<Role> roles = new HashSet<>();

}

  6. RedisServiceTest 测试类如下：

    package com.example.demo.service;

import com.example.demo.config.RedisConfiguration;
import com.example.demo.domain.User;
import com.example.demo.service.util.RedisKey;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author smileorsilence
 */
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisConfiguration.class, RedisService.class})
public class RedisServiceTest {

    @Autowired
    private RedisService redisService;

    @Test
    public void expireKey() throws Exception {

    }

    @Test
    public void saveMapValue() throws Exception {
        User user = new User();
        user.setId(1L);
        user.setUsername("红楼隔雨相望冷");
        user.setPassword("smileorsilence");
        redisService.saveMapValue(RedisKey.SMILEORSILENCE_USER, user.getId().toString(), user);
    }

    @Test
    public void readMapValue() throws Exception {
        User user = new User();
        user.setId(1L);
        user = (User) redisService.readMapValue(RedisKey.SMILEORSILENCE_USER, user.getId().toString());
        log.info(">>>>> >>>>> user <<<<< <<<<< {}", user);
    }

}

  7. 运行 saveMapValue 单元测试方法，测试通过，结果如下：
    测试结果1
    测试结果2

  8. 运行 readMapValue 单元测试方法，测试不通过，抛出异常如下：
    ClassCastException

  9. 抛出异常后修改 readMapValue 单元测试方法，使用 map 接收读取到的数据，方法如下：

    @Test
public void readMapValue() throws Exception {
    User user = new User();
    user.setId(1L);
    Map<String, Object> userMap = (Map<String, Object>) redisService.readMapValue(RedisKey.SMILEORSILENCE_USER, user.getId().toString());
    user.setUsername((String) userMap.get("username"));
    user.setPassword((String) userMap.get("password"));
    log.info(">>>>> >>>>> user <<<<< <<<<< {}", user);
}

  10. 修改测试方法后测试通过，但这样操作十分繁琐，尤其是遇到对象嵌套情况的时候。刚开始思考是不是 redis 使用的序列化和反序列化方式的问题，于是将自定义的 JsonRedisSerializer 序列化类替换成 SpringData 自带的 Jackson2JsonRedisSerializer 序列化类，发现结果一样。后来记起以前做过一个项目有类似的情况但是并没有抛出类型转换异常，将两者对比后修改 RedisConfiguration 配置类如下：

    package com.example.demo.config;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author smileorsilence
 */
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfiguration {

    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory redisConnectionFactory = new JedisConnectionFactory();
        redisConnectionFactory.setHostName(redisProperties.getHost());
        redisConnectionFactory.setPort(redisProperties.getPort());
        redisConnectionFactory.setDatabase(redisProperties.getDatabase());

        if (this.redisProperties.getPassword() != null)
            redisConnectionFactory.setPassword(redisProperties.getPassword());
        if (this.redisProperties.getTimeout() > 0) redisConnectionFactory.setTimeout(redisProperties.getTimeout());

        return redisConnectionFactory;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JsonRedisSerializer());
        //for hash
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new JsonRedisSerializer());
//        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));

        return redisTemplate;
    }

    public static class JsonRedisSerializer implements RedisSerializer<Object> {
        private ObjectMapper objectMapper = new ObjectMapper();

        public JsonRedisSerializer() {
            this.objectMapper = new ObjectMapper().enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
            this.objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        }

        @Override
        public byte[] serialize(Object o) throws SerializationException {
            if (o == null) {
                return new byte[0];
            } else {
                try {
                    return this.objectMapper.writeValueAsBytes(o);
                } catch (Exception e) {
                    throw new SerializationException("Could not write JSON: " + e.getMessage());
                }
            }
        }

        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
            if (bytes == null) {
                return null;
            } else {
                try {
                    return this.objectMapper.readValue(bytes, Object.class);
                } catch (Exception e) {
                    throw new SerializationException("Could not read JSON: " + e.getMessage());
                }
            }
        }
    }

}

    与之前的配置类相比增加了两行代码：

    this.objectMapper = new ObjectMapper().enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
this.objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

  11. 再次运行 saveMapValue 和 readMapValue 单元测试方法，测试通过，结果如下：
    测试结果3
    测试结果4

  12. 参考有关的博客文章，发现这两行代码的作用是将 json 转换成 java 对象，如果不设置则会默认将 json 转换成 hashmap，另外以上两行代码替换成如下代码后也可以通过测试：

    this.objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
this.objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

    只不过在Redis中存储的数据内容与前者稍有不同：
    测试结果5

SmileorSilence
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-boot学习笔记
11-06
springboot的入门技术，详细的介绍了相关的技术信息，从spring的注解开发到最终的springboot整合mybatis，redis集群的组合都有详细的介绍
SpringBoot下Redis相关配置是如何被初始化的
weixin_33726943的博客
07-17 1133
2019独角兽企业重金招聘Python工程师标准>>> ...
[原创]SpringBoot的自动配置原理与自定义SpringBootStarter
futao__的博客
11-02 494
以SpringBootAdmin的实现方式作为参考 实现的效果: 添加相关的依赖，再在启动类上加上@EnableXXX就可以使用相关的功能了。 原理-SpringBootAdmin为例 在启动类上标记注解@EnableAdminServer @EnableAdminServer @SpringBootApplication public class AdminApplica...
Redis系列三 - Spring boot如何使用redis做缓存及缓存注解的用法总结
热门推荐
不积跬步无以至千里; 不积小流无以成江海
07-19 4万+
本文介绍Spring boot 如何使用redis做缓存，如何对redis缓存进行定制化配置(如key的有效期)以及spring boot 如何初始化redis做缓存。使用具体的代码介绍了@Cacheable，@CacheEvict，@CachePut，@CacheConfig等注解及其属性的用法。
spring-boot-study:spring boot note--我自己的学习笔记，还有一些demo。包含docker、攻击技术、设计模式、安全通讯、redis集群等。还有一些mq的使用、aop日志、批量操作sql等
05-14
spring boot mysql mybatis druid redis lettuce swagger2 项目结构： spring-boot-study 父项目 web web项目继承自spring-boot-study api 接口统一定义，model统一定义 common 公共模块 controller 控制器 dao 数据...
狂神说Java 笔记，java入门，docker ,spring 全家桶，redis , mysql , vue , javascript ,htm5, css
05-07
所有笔记内容如下： 1、JavaSE：Java入门.pdf 2、JavaSE：基础语法.pdf 3、JavaSE：流程控制.pdf 4、JavaSE：方法.pdf 5、JavaSE：数组.pdf 6、JavaSE：面向对象.pdf 7、JavaSE：异常机制.pdf 8、JavaSE：...
《深入理解Spring Cloud与微服务构建》学习笔记(六)
10-23
《深入理解Spring Cloud与微服务构建》学习笔记(六)~SpringBoot 整合 Redis
研究：全栈工程师学习笔记； Spring登录，shiro登录，CAS单点登录和Spring boot oauth2单点登录； Spring数据缓存，支持Redis和EHcahce； web安全，常见的网络安全漏洞以及解决思路；常规组件，尺寸redis，mq等； quartz定时任务，支持持久化数据库，动态维护启动暂停关闭； docker基本用法，常用的镜像使用，Docker-MySQL，docker- Postgres，Docker-nginx，Docker-nexus，Docker-Redis，Dock
02-05
其他项目：Spring Cloud微服务学习笔记 Spring Boot项目实践 Java体系知识点汇总： : 网站资源链接 S3基本使用事件 数据库隔离等级验证 常用JVM命令验证 AOP实用技巧；某些打日志等 m3u解析器 知识汇总：：：：...
Spring Boot 学习笔记 10 : Flyway 异常
走马观花
06-01 2万+
最近使用 SpringBoot 集成 Mybatis 开发项目，关于数据库表结构的生成决定采用 Flyway 或者 Liquibase 这样的数据库版本工具，或者叫数据库迁移工具。在使用 Flyway 的过程中，遇到一些问题先记录下来。 在 application.properties 文件中配置 Flyway ## 是否启用flyway flyway.enabled=true ...
Spring Boot 学习笔记 3 : mvn spring-boot:run
走马观花
01-17 1万+
最近在看陈韶健写的《深入实践 Spring Boot》这本书，从 GitHub 上拷了 spring-boot-ui 项目的源码下来，项目地址点击这里 。在使用 mvn spring-boot:run 命令运行项目的时候出了些问题，记录下来，以后遇到类似问题或能引以为前车之鉴...
Spring Boot 学习笔记 4 : Thymeleaf
走马观花
01-24 7827
spring boot 学习笔记 : thymeleaf
Spring Boot 学习笔记 14 : JPA 双向多对多映射中间表插入数据失败
走马观花
02-19 3324
最近在做项目的权限控制这一块，在编写修改角色权限部分代码时遇到角色-权限中间表数据插入失败的问题，原因是将中间表维护放在了权限表这一端来进行。 角色实体类如下： @Entity @Table(name = "sys_role") public class Role implements Serializable { @Id @GeneratedValue(strategy ...
Spring Boot 学习笔记 2 : Random
走马观花
01-16 3247
The RandomValuePropertySource is useful for injecting random values (e.g. into secrets or test cases). It can produce integers, longs, uuids or strings, e.g...
Spring Boot 学习笔记 9 : EasyPoi
走马观花
06-01 2712
关于如何使用 SpringBoot 快速开发 Excel 表格导出功能，最近在网上找到一个使用比较轻便实用的第三方组件 easypoi，可以通过使用注解的方式来简化开发过程。而该组织开发者也提供了与 SpringBoot 集成的 Starter 启动器，maven 仓库地址 点击这里 。 首先在 pom.xml 文件中添加 maven 依赖： &amp;lt;!-- https://mvnr...
Spring Boot 学习笔记 6 : spring-boot-starter-mail
走马观花
04-13 2478
spring boot 学习笔记 : java mail
Spring Boot 学习笔记 13 : Thymeleaf th:onclick 解析异常
走马观花
02-15 2062
  为了引入 Thymeleaf 与 Spring Security 整合的依赖，将项目中 Thymeleaf 的版本从 3.0.0 升级到 3.0.11。   在这里列出 Thymeleaf 相关依赖如下，需要注意的是在 &amp;lt;properties&amp;gt; 标签中需指明依赖的版本。 &amp;lt;properties&amp;gt; &amp;lt;java.version&amp;gt;1.8&amp;lt;/jav
Spring Boot 学习笔记 1 : 自定义 Banner
走马观花
01-15 1711
The banner that is printed on start up can be changed by adding a banner.txt file to your classpath or by setting the spring.banner.location property to the location of such a file...
Spring Boot 学习笔记 15 : POI组件的Excel导出功能
走马观花
02-27 1638
在项目中开发 Excel 表格导出功能，之前使用比较轻便实用的第三方组件 easypoi，现在由于数据对象某字段值的中英文转换问题（例如将状态这一列值MATERIAL_OCCUPIED转换为存放产品），决定使用 Apache 的 POI 组件来代替 easypoi。 使用 easypoi 效果： 期望效果： 尽管 easypoi 原生 API 中@Excel注解中的replace属性结合Exp...
Spring Boot 学习笔记 7 : ZonedDateTime 和 Hibernate
走马观花
05-03 1588
最近项目的实体类中使用了 Java8 中新的日期和时间 API，在数据持久化时遇见一些曲折，记录下来作为前车之鉴。
• Web框架：Spring Boot • 字段校验：Spring Validation • 持久层：MyBatis-Plus • 接口文档：Swagger2 • 缓存：Redis • 工具：Hutool • 资源存储：阿里云对象存储OSS • 课程视频点播：阿里云视频点播VoD 详细介绍一下这些内容
最新发布
07-10
以上就是关于Spring Boot、Spring Validation、MyBatis-Plus、Swagger2、Redis、Hutool、阿里云对象存储OSS和阿里云视频点播VoD的详细介绍。如果您对其中任何一个内容有进一步的问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值