springboot+jpa+redis+quzartz+elasticsearch实现微信论坛小程序(三)

Redis的使用

pom

需要加入cache包及redis

        
        
            org.springframework.boot
            spring-boot-starter-cache
        
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
            2.1.3.RELEASE
        

yml

配置redis的基本参数

  ##redis配置,默认密码为空
  redis:
    host: localhost
    # Redis服务器连接端口
    port: 6379
    jedis:
      pool:
        #连接池最大连接数(使用负值表示没有限制)
        max-active: 100
        # 连接池中的最小空闲连接
        max-idle: 10
        # 连接池最大阻塞等待时间(使用负值表示没有限制)
        max-wait: 100000
    # 连接超时时间(毫秒)
    timeout: 5000
    #默认是索引为0的数据库
    database: 0

redis配置类

需要配置能够使用@Cacheable@CacheEvict注解来进行缓存,同时也需要使用redisTemplate进行一些操作,所以要配置CacheManagerRedisTemplateSpringboot使用的序列化方式为jdkSerializable,存储的是二进制字节码,不易读并且很长,于是使用Jackson2JsonRedisSerializer做为值的序列化方法,键的序列化方法还是使用String

@Configuration
@EnableCaching
@Slf4j
public class RedisConfig {

    private static final Duration timeToLive = Duration.ofDays(1);

    /**
     * 采用RedisCacheManager作为缓存管理器
     * @param connectionFactory
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        // 1.设置redis缓存配置
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(timeToLive) //设置过期时间
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer())) // 设置键的序列化方式
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer())) // 设置值得序列化方式
                .disableCachingNullValues(); //不缓存空值
        // 2.建立redis缓存管理
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(redisCacheConfiguration)
                .transactionAware()
                .build();
        log.info("自定义RedisCacheManager加载完成");
        return redisCacheManager;
    }

    /**
     * redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 1.建立redis模板类
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 2.设置value的序列化规则和 key的序列化规则
        redisTemplate.setValueSerializer(valueSerializer());
        redisTemplate.setKeySerializer(keySerializer());
        redisTemplate.setHashKeySerializer(keySerializer());
        redisTemplate.setHashValueSerializer(keySerializer());
        redisTemplate.afterPropertiesSet();
        log.info("自定义RedisTemplate加载完成");
        return redisTemplate;
    }


    /**
     * 键的序列化方法
     * @return
     */
    private RedisSerializer keySerializer() {
        return new StringRedisSerializer();
    }

    /**
     * 值的序列化方法
     * @return
     */
    private RedisSerializer valueSerializer() {
        // 1.创建 序列化类
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        // 2.设置可见度
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 3.启动默认的类型
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        // 4.序列化类,对象映射设置
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        return jackson2JsonRedisSerializer;
    }
}
 
 

实体类到map的互换

为了可以直接将实体存到redishash类型,写一个实体与map转换的工具类,需要引入beanutils的依赖:


    commons-beanutils
    commons-beanutils
    1.9.3

public class EntityUtils {

    public static Map objectToHash(Object obj) {
        try {
            Map map = new HashMap();
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                if (!property.getName().equals("class")) {
                    if (property.getReadMethod().invoke(obj) != null) {
                        // 时间类型会错乱所以吧时间手动转换成long;
                        if (property.getReadMethod().invoke(obj) != null) {
                            if ("java.util.Date".equals(property.getPropertyType().getTypeName())) {
                                Date invoke = (Date) property.getReadMethod().invoke(obj);
                                long time = invoke.getTime();
                                map.put(property.getName(), String.valueOf(time));
                            } else {
                                map.put(property.getName(), "" + property.getReadMethod().invoke(obj));
                            }
                        }
                    }
                }
            }
            return map;
        } catch (InvocationTargetException | IllegalAccessException | IntrospectionException e) {
            throw new RuntimeException(e);
        }
    }

    public static  T hashToObject(Map map, Class t) {
        // 转换注册器
        ConvertUtils.register(new LongConverter(null), Long.class);
        ConvertUtils.register(new ByteConverter(null), Byte.class);
        ConvertUtils.register(new IntegerConverter(null), Integer.class);
        ConvertUtils.register(new DoubleConverter(null), Double.class);
        ConvertUtils.register(new ShortConverter(null), Short.class);
        ConvertUtils.register(new FloatConverter(null), Float.class);
        ConvertUtils.register(new Converter() {
            public Object convert(Class type, Object value) {
                if (value == null) {
                    return null;
                }
                return new Date(Long.valueOf((String) value));
            }
        }, Date.class);

        try {
            Object o = t.newInstance();
            BeanUtils.populate(o, (Map) map);
            return (T) o;

        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        return null;
    }
}

这样就可以在项目中使用redis,并且可以方便的把实体类直接存入redishash类型中了。

微信小程序

pom

        
        
            com.github.binarywang
            weixin-java-miniapp
            3.3.0
        

yml

wechat:
  appId: 小程序appid
  appSecret: 小程序secret

小程序账户配置

@Component
@Data
@ConfigurationProperties(prefix = "wechat")
public class WeChatAccountCogfig {

    /**
     * 公众平台id
     */
    private String appId;

    /**
     * 公众平台secret
     */
    private String appSecret;
}

小程序配置类

@Configuration
public class WeChatMaConfig {

    @Autowired
    WeChatAccountCogfig weChatAccountCogfig;

    @Bean
    public WxMaService wxMaService(){
        WxMaService wxMaService = new WxMaServiceImpl();
        wxMaService.setWxMaConfig(wxMaConfigStorage());
        return wxMaService;
    }

    @Bean
    public WxMaInMemoryConfig wxMaConfigStorage(){
        WxMaInMemoryConfig wxMaInMemoryConfig = new WxMaInMemoryConfig();
        wxMaInMemoryConfig.setAppid(weChatAccountCogfig.getAppId());
        wxMaInMemoryConfig.setSecret(weChatAccountCogfig.getAppSecret());
        return wxMaInMemoryConfig;
    }
}

小程序配置也完成了,我们看一下微信小程序登录流程。

登录流程

微信小程序文档

微信小程序登录流程

说明:

  1. 调用 wx.login() 获取 临时登录凭证code ,并回传到开发者服务器。
  2. 调用 auth.code2Session 接口,换取 用户唯一标识 OpenID会话密钥 session_key

之后开发者服务器可以根据用户标识来生成自定义登录态,用于后续业务逻辑中前后端交互时识别用户身份。

注意:

  1. 会话密钥 session_key 是对用户数据进行 加密签名 的密钥。为了应用自身的数据安全,开发者服务器不应该把会话密钥下发到小程序,也不应该对外提供这个密钥
  2. 临时登录凭证 code 只能使用一次
    了解了基本的登录流程,我们就可以开始写小程序的登录模块了。

小程序登录Controller

主要分为两个部分,登录模块和获取用户信息模块。对登录模块,选择redis进行3rd_sessionId的存储,3rd_sessionId的生成使用sessionKey+openId+currentTimeMillis()进行MD5加密后的结果,当重复登录时需要使之前的3rd_sessionId失效,所以需要使用键sessionId保存session信息,用键openId保存sessionId信息,当发现有当前用户的3rd_sessionId还没失效,又进行的登录,则删除旧的3rd_sessionId,将3rd_sessionId有效期设置为30天。
获取sessionKey及解密获得用户信息都是使用了微信小程序SDK,很好用的SDK,还有配套的demo,推荐给大家。

@RestController
@Slf4j
@RequestMapping("/wechat")
public class WeChatController {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private WxMaService wxMaService;

    @Autowired
    private UserServiceImpl userService;

    @GetMapping("/login")
    public ResultVO WeChatLogin(@RequestParam String code){
        String sessionId;
        try{
            // 0.如果code为空,返回错误信息
            if (code==null||code.isEmpty()){
                return ResultVOUtil.error(ResultEnum.CODE_ERROR.getCode(), ResultEnum.CODE_ERROR.getMessage());
            }
            // 1.向微信服务器获取openid和sessionKey
            WxMaJscode2SessionResult session = wxMaService.getUserService().getSessionInfo(code);
            if (session==null){
                return ResultVOUtil.error(ResultEnum.SESSION_ERROR.getCode(), ResultEnum.SESSION_ERROR.getMessage());
            }
            String sessionKey = session.getSessionKey();
            String openId = session.getOpenid();
            // 3.根据openid查询用户是否存在
            User user = userService.findUser(session.getOpenid());
            // 4.若用户不存在则创建用户
            if (user == null){
                userService.createUser(session.getOpenid());
            }
            // 5.查看redis中是否有登录信息
            if (redisTemplate.hasKey("openId::" + openId)){
                redisTemplate.delete(redisTemplate.opsForValue().get("openId::" + openId));
            }
            // 6.生成加密的sessionId;
            sessionId = KeyUtil.getSessionId(sessionKey+openId+System.currentTimeMillis());
            // 7.存入redis中
            redisTemplate.opsForValue().set("sessionId::" + sessionId, session,30, TimeUnit.DAYS);
            redisTemplate.opsForValue().set("openId::" + openId, "sessionId::" + sessionId, 30, TimeUnit.DAYS);
        }catch (WxErrorException e){
            log.error(e.getMessage(), e);
            return ResultVOUtil.error(e.getError().getErrorCode(), e.getError().getErrorMsg());
        }
        // 8.返回第三方sessionId交由客户端保存
        HashMap map = new HashMap();
        map.put("sessionId", sessionId);
        return ResultVOUtil.success(map);
    }

    @PostMapping("/info")
    public ResultVO WeChatInfo(@RequestParam String sessionId,
                                       @RequestBody UserInfoForm userInfoForm){
        String rawData = userInfoForm.getRawData();
        String signature = userInfoForm.getSignature();
        String encryptedData = userInfoForm.getEncryptedData();
        String iv = userInfoForm.getIv();
        // 1.查看是否有sessionId信息
        if (!redisTemplate.hasKey("sessionId::" + sessionId)){
            return ResultVOUtil.error(ResultEnum.SESSION_ID_NULL.getCode(), ResultEnum.SESSION_ID_NULL.getMessage());
        }
        // 2.从sessionId中取出sessionKey
        WxMaJscode2SessionResult session = (WxMaJscode2SessionResult) redisTemplate.opsForValue().get("sessionId::" + sessionId);
        String sessionKey = session.getSessionKey();
        // 3.校验用户信息
        if (!wxMaService.getUserService().checkUserInfo(sessionKey, rawData, signature)) {
            return ResultVOUtil.error(ResultEnum.USER_INFO_ERROR.getCode(), ResultEnum.USER_INFO_ERROR.getMessage());
        }
        // 4.解密用户信息
        WxMaUserInfo userInfo = wxMaService.getUserService().getUserInfo(sessionKey, encryptedData, iv);
        // 5.更新用户信息
        User user = userService.updateUser(userInfo);
        return ResultVOUtil.success(user);
    }
}

至此,小程序登录的模块已经完成,下一章会介绍主要的业务模块,包括帖子、评论及上传图片到七牛云对象存储。
上一篇:springboot+jpa+redis+quzartz+elasticsearch实现微信论坛小程序(二)
下一篇:springboot+jpa+redis+quzartz+elasticsearch实现微信论坛小程序(四)

你可能感兴趣的:(springboot+jpa+redis+quzartz+elasticsearch实现微信论坛小程序(三))