public class FastJsonRedisSerializer<T> implements RedisSerializer<T> { public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8; private final Class<T> clazz; static { ParserConfig.getGlobalInstance().setAutoTypeSupport(true); } public FastJsonRedisSerializer(Class<T> clazz) { super(); this.clazz = clazz; } @Override public byte[] serialize(T t) throws SerializationException { if (t == null) { return new byte[0]; } return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET); } @Override public T deserialize(byte[] bytes) throws SerializationException { if (bytes == null || bytes.length <= 0) { return null; } String str = new String(bytes, DEFAULT_CHARSET); return JSON.parseObject(str, clazz); } protected JavaType getJavaType(Class<?> clazz) { return TypeFactory.defaultInstance().constructType(clazz); } }

这段代码是一个使用 FastJson 序列化和反序列化对象的 Redis 序列化器。它实现了 RedisSerializer 接口，并使用 FastJson 库来进行对象的序列化和反序列化操作。

在这段代码中，有以下几个关键点：

1. 使用了泛型 T，表示序列化和反序列化的对象类型。
2. 通过构造方法传入了需要序列化和反序列化的对象类型。
3. 在序列化方法中，先判断对象是否为空，为空则返回空字节数组。否则，使用 FastJson 将对象转换为 JSON 字符串，并使用指定的字符集编码为字节数组。
4. 在反序列化方法中，先判断字节数组是否为空，为空则返回 null。否则，将字节数组使用指定的字符集解码为字符串，然后使用 FastJson 将字符串解析为指定的对象类型。

此外，在静态代码块中，还设置了 FastJson 的全局配置，将自动类型支持设置为 true，以支持序列化和反序列化时保留对象的类信息。

这个 Redis 序列化器可以用于将对象存储到 Redis 中或从 Redis 中读取对象，并将其转换为指定的 Java 对象。

相关问题

redis怎么存取java实体

在Java中，我们可以使用RedisTemplate来存取Java实体。首先，我们需要配置RedisTemplate，可以通过实现Redis的序列化来实现。可以使用FastJsonRedisSerializer类来实现序列化。接着，我们可以使用redisTemplate.opsForValue().set()方法来将Java实体存入Redis中，其中需要将Java实体转换为JSON字符串。在获取Java实体时，我们可以使用redisTemplate.opsForValue().get()方法获取JSON字符串，然后使用JSON.parseObject()方法将JSON字符串转换为Java实体。具体实现可以参考以下代码：

1. 配置类：

@Configuration
public class RedisConfig {

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

class FastJsonRedisSerializer<T> implements RedisSerializer<T> {

    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (t == null) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return JSON.parseObject(str, clazz);
    }
}

2. 实体类：

public class UserVO implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;

    private String username;

    private String password;

    // getter and setter
}

3. 存入Java实体：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void setUser(UserVO user) {
    redisTemplate.opsForValue().set("user:" + user.getId(), user);
}

4. 获取Java实体：

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public UserVO getUser(Long id) {
    return (UserVO) redisTemplate.opsForValue().get("user:" + id);
}

feign 序列化_Spring Cloud Feign 配置 FastJson

要在Spring Cloud Feign中配置FastJson序列化，您需要完成以下步骤：

1. 添加FastJson依赖

在项目的pom.xml文件中，添加FastJson依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

2. 创建FastJson转换器

创建一个FastJson转换器类，继承自Spring的HttpMessageConverter接口，并实现其方法。代码如下：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Type;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

public class FastJsonHttpMessageConverter implements HttpMessageConverter<Object> {

    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private SerializerFeature[] serializerFeatures = new SerializerFeature[0];
    private Feature[] parserFeatures = new Feature[0];

    @Override
    public boolean canRead(Type type, Class<?> contextClass, MediaType mediaType) {
        return true;
    }

    @Override
    public boolean canWrite(Type type, Class<?> aClass, MediaType mediaType) {
        return true;
    }

    @Override
    public List<MediaType> getSupportedMediaTypes() {
        List<MediaType> mediaTypes = new ArrayList<>();
        mediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        mediaTypes.add(MediaType.APPLICATION_JSON);
        mediaTypes.add(MediaType.TEXT_PLAIN);
        return mediaTypes;
    }

    @Override
    public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage) throws IOException {
        InputStream inputStream = inputMessage.getBody();
        return JSON.parseObject(inputStream, DEFAULT_CHARSET, type, parserFeatures);
    }

    @Override
    public void write(Object o, Type type, MediaType mediaType, HttpOutputMessage outputMessage) throws IOException {
        HttpHeaders headers = outputMessage.getHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        String jsonString = JSON.toJSONString(o, serializerFeatures);
        OutputStream outputStream = outputMessage.getBody();
        outputStream.write(jsonString.getBytes(DEFAULT_CHARSET));
        outputStream.flush();
    }

    public SerializerFeature[] getSerializerFeatures() {
        return serializerFeatures;
    }

    public void setSerializerFeatures(SerializerFeature[] serializerFeatures) {
        this.serializerFeatures = serializerFeatures;
    }

    public Feature[] getParserFeatures() {
        return parserFeatures;
    }

    public void setParserFeatures(Feature[] parserFeatures) {
        this.parserFeatures = parserFeatures;
    }
}

3. 配置FastJson转换器

在Spring的配置类中，创建一个FastJson转换器的bean，并将其注册到Spring的HttpMessageConverters中。代码如下：

import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class FeignConfiguration {

    @Bean
    public HttpMessageConverter fastJsonHttpMessageConverter() {
        return new FastJsonHttpMessageConverter();
    }

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        converter.setObjectMapper(new ObjectMapper());
        messageConverters.add(converter);
        messageConverters.add(fastJsonHttpMessageConverter());
        restTemplate.setMessageConverters(messageConverters);
        return restTemplate;
    }
}

4. 配置Feign Client

在Feign Client的配置类中，使用@FeignClient注解的configuration属性，将FastJson转换器的bean引入到Feign Client中。代码如下：

import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableFeignClients(defaultConfiguration = {FeignConfiguration.class})
public class FeignClientConfiguration {
}

完成以上步骤之后，您就可以在Spring Cloud Feign中使用FastJson作为序列化工具了。