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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Author: lvxianchao
 * Date: 2023-03-03 14:32
 * Description: Redis Config
 */
@Configuration
public class RedisConfig {
    
    @Bean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        // 连接池
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 序列化器
        redisTemplate.setDefaultSerializer(new StringRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 支持事务
        redisTemplate.setEnableTransactionSupport(true);
        
        return redisTemplate;
    }

    /**
     * Redis Key 过期监听
     *
     * @param redisConnectionFactory RedisConnectionFactory
     *
     * @return RedisMessageListenerContainer
     */
    @Bean
    RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory redisConnectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        
        return container;
    }
    
}

/**
 * 获取远程图片的 base64
 *
 * @param remoteImageUrl 远程图片地址
 *
 * @return 图片的 base64
 */
public static String getRemoteImageBase64(String remoteImageUrl) {
    try {
        StringBuilder builder = new StringBuilder("data:");
        
        URL url = new URL(remoteImageUrl);
        String type = url.openConnection().getContentType();
        builder.append(type).append(";base64,");
        
        BufferedImage bufferedImage = ImageIO.read(url.openStream());
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        ImageIO.write(bufferedImage, "png", stream);
        String base64 = Base64.getEncoder().encodeToString(stream.toByteArray());
        builder.append(base64);
        
        return builder.toString();
    } catch (IOException e) {
        log.warn("读取远程图片信息失败: {}", e.getMessage());
        return null;
    }
}

package BusinessHelper.config;

import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.math.BigInteger;

/**
 * Author: hcryeo
 * Date: 2023-05-11 13:44
 * Description:
 */
@Slf4j
@Configuration
public class JacksonConfig {

    /**
     * 注册 Jackson 全局 Long 类型转为 String 类型，解决前端 Long 类型精度丢失的问题
     *
     * @return Jackson2ObjectMapperBuilderCustomizer
     */
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return jacksonObjectMapperBuilder -> {
            jacksonObjectMapperBuilder.serializerByType(BigInteger.class, ToStringSerializer.instance);
            jacksonObjectMapperBuilder.serializerByType(Long.class, ToStringSerializer.instance);
        };
    }

}

jacksonObjectMapperBuilder.serializerByType(Long.TYPE, ToStringSerializer.instance);

package com.example.demo.entity;

import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;
import lombok.ToString;
import org.hibernate.Hibernate;

import javax.annotation.PostConstruct;
import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;

/**
 * Author: lvxianchao
 * Date: 2023-01-09 11:16
 * Description:
 */
@Getter
@Setter
@ToString
@RequiredArgsConstructor
@Entity
@Table(name = "user")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;
    
    @Column(name = "name")
    private String name;
    
    @Column(name = "email")
    private String email;
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || Hibernate.getClass(this) != Hibernate.getClass(o)) return false;
        User user = (User) o;
        return id != null && Objects.equals(id, user.id);
    }
    
    @Override
    public int hashCode() {
        return getClass().hashCode();
    }
    @PostConstruct
    public void init(){
    
    }
}

package com.example.demo.controller;

import com.example.demo.dto.UserIndexDTO;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

/**
 * Author: lvxianchao
 * Date: 2023-01-09 11:16
 * Description:
 */
@RestController
public class UserController {
    
    @Resource
    UserService service;
    
    @GetMapping("/")
    public List<User> index(UserIndexDTO dto) {
        System.out.println("dto = " + dto);
        return service.index(dto);
    }
    
    @GetMapping("/{id}")
    public User show(@PathVariable Long id) {
        return service.show(id);
    }
}

package com.example.demo.dto;

import lombok.Data;

/**
 * Author: lvxianchao
 * Date: 2023-01-09 13:08
 * Description:
 */
@Data
public class UserIndexDTO {
    private Long id;
    private String name;
    private String email;
}

package com.example.demo.service;

import com.example.demo.dto.UserIndexDTO;
import com.example.demo.entity.QUser;
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import com.querydsl.jpa.impl.JPAQuery;
import com.querydsl.jpa.impl.JPAQueryFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

/**
 * Author: lvxianchao
 * Date: 2023-01-09 11:17
 * Description:
 */
@Service
public class UserService {
    
    @Resource
    UserRepository repository;
    
    @PersistenceContext
    private EntityManager entityManager;
    
    public List<User> index(UserIndexDTO dto) {
        QUser user = QUser.user;
        JPAQueryFactory query = new JPAQueryFactory(entityManager);
        JPAQuery<User> selectFrom = query.selectFrom(user);
        
        if (dto.getId() != null) {
            System.out.println("dto.getId() = " + dto.getId());
            selectFrom.where(user.id.eq(dto.getId()));
        }
        
        if (dto.getName() != null) {
            System.out.println("dto.getName() = " + dto.getName());
            selectFrom.where(user.name.eq(dto.getName()));
        }
        
        if (dto.getEmail() != null) {
            System.out.println("dto.getEmail() = " + dto.getEmail());
            selectFrom.where(user.email.eq(dto.getEmail()));
        }
        
        return selectFrom.fetch();
    }
    
    public User show(Long id) {
        QUser user = QUser.user;
        JPAQueryFactory query = new JPAQueryFactory(entityManager);
        User first = query.selectFrom(user).where(user.id.eq(id)).fetchFirst();
        return first;
    }
}

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * Author: lvxianchao
 * Date: 2023-01-09 11:16
 * Description:
 */
public interface UserRepository extends JpaRepository<User, Long> {
}

package com.lvxianchao.translation.config;

import org.hibernate.dialect.MySQLDialect;

/**
 * Author: lvxianchao
 * Date: 2023-01-12 17:36
 * Description:
 */
public class MySQL5UTF8mb4Dialect extends MySQLDialect {
    
    @Override
    public String getTableTypeString() {
        return "engine = innodb default charset = utf8mb4";
    }
    
}