星月梦瑾
星月梦瑾

基于Spring的单点登录SSO实现（redis+JWT+SpringSecurity）

本文介绍了基于Spring的单点登录SSO实现（redis+JWT+SpringSecurity） 方法。

一、应用场景

       平台包含多个系统应用的，实现只要在一个应用登录一次，就可以访问其他相互信任的应用。常用于多应用平台中，此时常常建立门户网站系统，进行单点登录。

二、实现思路

    单点登录可基于cookie、session、token等方式。本文主要基于token和redis实现。

     登录信息及token通常存储于redis中，鉴权和校验时需要取redis的用户信息。正常单个应用只有一个服务器的一个redis数据库，同时存储其他业务信息（字典、应用系统配置、其他业务数据）和登录信息，在同一数据库中以key值区分。在没有引入单点登录时，由于多应用的其他业务信息（字典、应用系统配置、其他业务数据）和登录信息有相同的key会冲突，所以应用之间的数据库是不同的。

    单点登录的实现主要是将所有应用的登录信息存储到同一个redis数据库中，而各自的业务信息依然存储到原来应用自己的数据库。这样使得各个子系统登录信息实现共享，校验登录状态和token时取自同一信息，其他业务数据进行分离。

      因此相当于将redis设置主库从库。实现时主要应用注解@primary、@Qualifier

@Bean、@ConfigurationProperties

三、实现方法

1、配置文件

三个系统如下设置，redis配置子系统的数据（datasebase不同），token-redis配置存储token的数据（database相同）

子系统1

子系统2

子系统3

业务数据存储

10.110.1.1:6379 database: 1

10.110.1.1:6379 database: 2

10.110.12.1:6379 database: 3

Token及登录信息存储

10.110.1.1:6379 database: 4

10.110.1.1:6379 database: 4

10.110.1.1:6379 database: 4

 
redis:
  # 地址
  host: 10.110.1.1:6379
  # 端口，默认为6379
  port: 6379
  # 数据库索引
  database: 1
  # 密码
  password: root
  # 连接超时时间
  timeout: 10s
  lettuce:
    pool:
      # 连接池中的最小空闲连接
      min-idle: 0
      # 连接池中的最大空闲连接
      max-idle: 8
      # 连接池的最大数据库连接数
      max-active: 8
      # #连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1ms
token-redis:
  # 地址
  host: 10.110.1.1
  # 端口，默认为6379
  port: 6379
  # 数据库索引
  database: 4
  # 密码
  password: root
  # 连接超时时间(s)
  timeout: 10s
  lettuce:
    pool:
      # 连接池中的最小空闲连接
      min-idle: 0
      # 连接池中的最大空闲连接
      max-idle: 8
      # 连接池的最大数据库连接数
      max-active: 8
      # #连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1ms

2、redisConfig配置的主要注解和方法

src/main/java/com/inspur/framework/config/RedisConfig.java

（1）配置读取

 @ConfigurationProperties(prefix = "spring.token-redis")

 @ConfigurationProperties(prefix = "spring.token")

区分配置文件的连接，firstRedisProperties和secondRedisProperties返回RedisProperties连接配置

@Primary  

不同类实现同一接口时，不注明名称则默认用当下的bean，注解在子系统的默认redis配置

@Bean(name = "mainRedisProperties")

@Bean(name = "tokenRedisProperties")

给返回的配置RedisProperties命名，在传参时标注@Qualifier配合使用。@Bean在项目启动时生成。

（2）连接方法

连接池配置并和redis建立连接，连接参数由@Qualifier指定

// 单系统默认配置

@Primary
@Bean(name = "redisConnectionFactory")
public RedisConnectionFactory redisConnectionFactory(@Qualifier("mainRedisProperties") RedisProperties redisProperties) {

// redis单体模式连接配置
RedisStandaloneConfiguration standaloneConfig = new RedisStandaloneConfiguration();
standaloneConfig.setHostName(redisProperties.getHost());
standaloneConfig.setPort(redisProperties.getPort());
standaloneConfig.setDatabase(redisProperties.getDatabase());
standaloneConfig.setPassword(RedisPassword.of(redisProperties.getPassword()));
standaloneConfig.setDatabase(redisProperties.getDatabase());
redisConfig = standaloneConfig;

// lettuce连接池配置
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
RedisProperties.Lettuce lettuce = redisProperties.getLettuce();
if(lettuce.getPool() != null) {
    RedisProperties.Pool pool = redisProperties.getLettuce().getPool();
    // 连接池最大连接数
    poolConfig.setMaxTotal(pool.getMaxActive());
    // 连接池中的最大空闲连接
    poolConfig.setMaxIdle(pool.getMaxIdle());
    // 连接池中的最小空闲连接
    poolConfig.setMinIdle(pool.getMinIdle());
    // 连接池最大阻塞等待时间（使用负值表示没有限制）
    poolConfig.setMaxWaitMillis(pool.getMaxWait().toMillis());
}
LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
// timeout
if(redisProperties.getTimeout() != null) {
    builder.commandTimeout(redisProperties.getTimeout());
}
// shutdownTimeout
if(lettuce.getShutdownTimeout() != null) {
    builder.shutdownTimeout(lettuce.getShutdownTimeout());
}
// 创建Factory对象
LettuceClientConfiguration clientConfig = builder.poolConfig(poolConfig).build();
return new LettuceConnectionFactory(redisConfig, clientConfig);

}

// tokenredis配置 

@Bean(name = "tokenRedisConnectionFactory")
public RedisConnectionFactory tokenRedisConnectionFactory(@Qualifier("tokenRedisProperties") RedisProperties redisProperties) {

// 同上

}

  (3) 连接池变量

用于实际业务中需要操作redis时的变量注入

@Bean(name = "redisTemplate")
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public RedisTemplate redisTemplate(@Qualifier("redisConnectionFactory") RedisConnectionFactory connectionFactory)
{

RedisTemplate template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);

// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(fastJson2JsonRedisSerializer);

// Hash的key也采用StringRedisSerializer的序列化方式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(fastJson2JsonRedisSerializer);

template.afterPropertiesSet();
return template;

}

（4）连接redis数据库操作

@Bean(name = "tokenRedisTemplate")
public RedisTemplate tokenRedisTemplate(@Qualifier("tokenRedisConnectionFactory") RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);

    // 使用StringRedisSerializer来序列化和反序列化redis的key值
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(fastJson2JsonRedisSerializer);

    // Hash的key也采用StringRedisSerializer的序列化方式
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(fastJson2JsonRedisSerializer);

    template.afterPropertiesSet();
    return template;
}

3、RedisToken增删改查操作

com/common/core/redis/RedisTokenCache.java

与原有的RedisCache.java相比基本相同，主要时redisTemplate采用的连接不同，通过注解指定名称实现@Qualifier("tokenRedisTemplate")

    @Autowired
    @Qualifier("tokenRedisTemplate")
    public RedisTemplate redisTemplate


@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisTokenCache {
    @Autowired
    @Qualifier("tokenRedisTemplate")
    public RedisTemplate redisTemplate;


public  void setCacheObject(final String key, final T value) {
    redisTemplate.opsForValue().set(key, value);
}

//其他


}

4、使用

主要集中在tokenService.java、UserDetailsServiceImpl.java等文件中

在用到登陆信息的存储、更新、获取时，均使用

@Autowired
private RedisTokenCache redisTokenCache;

操作，

主要集中在tokenService.java、UserDetailsServiceImpl.java等文件中。

// 登录方法

@Component
public class TokenService{

@Autowired
private RedisTokenCache redisTokenCache;

public LoginUser getLoginUser(HttpServletRequest request)
{
    // 获取请求携带的令牌
    String token = getToken(request);
    if (StringUtils.isNotEmpty(token))
    {
        try
        {
            Claims claims = parseToken(token);
            // 解析对应的权限以及用户信息
            String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
            String userKey = getTokenKey(uuid);
            LoginUser user = redisTokenCache.getCacheObject(userKey);
            return user;
        }
        catch (Exception e)
        {
        }
    }
    return null;
}

// 更新token方法

public void refreshToken(LoginUser loginUser)
{
    loginUser.setLoginTime(System.currentTimeMillis());
    loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
    // 根据uuid将loginUser缓存
    String userKey = getTokenKey(loginUser.getToken());
    redisTokenCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
}

四、实现示例

1、RedisConfig.java

package com.framework.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * redis配置
 *
 * @author Inspur
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{
    private static final Long TTL_DAY = 60 * 60 * 24L;
    private static final Long TTL_WEEK = 60 * 60 * 24 * 7L;
    private static final Long TTL_MONTH = 60 * 60 * 24 * 30L;

    private static final RedisSerializer strSerializer = new StringRedisSerializer();
    @SuppressWarnings(value = {"rawtypes"})
    private static final FastJson2JsonRedisSerializer fastJson2JsonRedisSerializer = new FastJson2JsonRedisSerializer<>(Object.class);

    /**
     * 主要业务redis缓存，以业务redis为主，兼容后续的redisson
     * @return
     */
    @Primary
    @Bean(name = "mainRedisProperties")
    @ConfigurationProperties(prefix = "spring.redis")
    public RedisProperties firstRedisProperties() {
        return new RedisProperties();
    }

    /**
     * token认证存储的redis缓存
     * @return
     */
    @Bean(name = "tokenRedisProperties")
    @ConfigurationProperties(prefix = "spring.token-redis")
    public RedisProperties secondRedisProperties() {
        return new RedisProperties();
    }

    /**
     * 以业务redis为主，兼容后续的redisson
     * @param redisProperties
     * @return
     */
    @Primary
    @Bean(name = "redisConnectionFactory")
    public RedisConnectionFactory redisConnectionFactory(@Qualifier("mainRedisProperties") RedisProperties redisProperties) {
        // redis单体模式连接配置
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
        redisConfig.setHostName(redisProperties.getHost());
        redisConfig.setPort(redisProperties.getPort());
        redisConfig.setDatabase(redisProperties.getDatabase());
        redisConfig.setPassword(RedisPassword.of(redisProperties.getPassword()));
        redisConfig.setDatabase(redisProperties.getDatabase());

        // lettuce连接池配置
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        RedisProperties.Lettuce lettuce = redisProperties.getLettuce();
        if(lettuce.getPool() != null) {
            RedisProperties.Pool pool = redisProperties.getLettuce().getPool();
            // 连接池最大连接数
            poolConfig.setMaxTotal(pool.getMaxActive());
            // 连接池中的最大空闲连接
            poolConfig.setMaxIdle(pool.getMaxIdle());
            // 连接池中的最小空闲连接
            poolConfig.setMinIdle(pool.getMinIdle());
            // 连接池最大阻塞等待时间（使用负值表示没有限制）
            poolConfig.setMaxWaitMillis(pool.getMaxWait().toMillis());
        }
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
        // timeout
        if(redisProperties.getTimeout() != null) {
            builder.commandTimeout(redisProperties.getTimeout());
        }
        // shutdownTimeout
        if(lettuce.getShutdownTimeout() != null) {
            builder.shutdownTimeout(lettuce.getShutdownTimeout());
        }
        // 创建Factory对象
        LettuceClientConfiguration clientConfig = builder.poolConfig(poolConfig).build();

        return new LettuceConnectionFactory(redisConfig, clientConfig);
    }

    @Bean(name = "tokenRedisConnectionFactory")
    public RedisConnectionFactory tokenRedisConnectionFactory(@Qualifier("tokenRedisProperties") RedisProperties redisProperties) {
        // redis单体模式连接配置
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
        redisConfig.setHostName(redisProperties.getHost());
        redisConfig.setPort(redisProperties.getPort());
        redisConfig.setDatabase(redisProperties.getDatabase());
        redisConfig.setPassword(RedisPassword.of(redisProperties.getPassword()));
        redisConfig.setDatabase(redisProperties.getDatabase());

        // lettuce连接池配置
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        RedisProperties.Lettuce lettuce = redisProperties.getLettuce();
        if(lettuce.getPool() != null) {
            RedisProperties.Pool pool = redisProperties.getLettuce().getPool();
            // 连接池最大连接数
            poolConfig.setMaxTotal(pool.getMaxActive());
            // 连接池中的最大空闲连接
            poolConfig.setMaxIdle(pool.getMaxIdle());
            // 连接池中的最小空闲连接
            poolConfig.setMinIdle(pool.getMinIdle());
            // 连接池最大阻塞等待时间（使用负值表示没有限制）
            poolConfig.setMaxWaitMillis(pool.getMaxWait().toMillis());
        }
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
        // timeout
        if(redisProperties.getTimeout() != null) {
            builder.commandTimeout(redisProperties.getTimeout());
        }
        // shutdownTimeout
        if(lettuce.getShutdownTimeout() != null) {
            builder.shutdownTimeout(lettuce.getShutdownTimeout());
        }
        // 创建Factory对象
        LettuceClientConfiguration clientConfig = builder.poolConfig(poolConfig).build();

        return new LettuceConnectionFactory(redisConfig, clientConfig);
    }


    /**
     * 主要业务缓存的redis
     * @param connectionFactory
     * @return
     */
    @Bean(name = "redisTemplate")
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    public RedisTemplate redisTemplate(@Qualifier("redisConnectionFactory") RedisConnectionFactory connectionFactory)
    {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(fastJson2JsonRedisSerializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(fastJson2JsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }

    /**
     * token业务缓存的redis
     * @param redisConnectionFactory
     * @return
     */
    @Bean(name = "tokenRedisTemplate")
    public RedisTemplate tokenRedisTemplate(@Qualifier("tokenRedisConnectionFactory") RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(fastJson2JsonRedisSerializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(fastJson2JsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public DefaultRedisScript limitScript()
    {
        DefaultRedisScript redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(limitScriptText());
        redisScript.setResultType(Long.class);
        return redisScript;
    }

    /**
     * 限流脚本
     */
    private String limitScriptText()
    {
        return "local key = KEYS[1]\n" +
                "local count = tonumber(ARGV[1])\n" +
                "local time = tonumber(ARGV[2])\n" +
                "local current = redis.call('get', key);\n" +
                "if current and tonumber(current) > count then\n" +
                "    return current;\n" +
                "end\n" +
                "current = redis.call('incr', key)\n" +
                "if tonumber(current) == 1 then\n" +
                "    redis.call('expire', key, time)\n" +
                "end\n" +
                "return current;";
    }

    /**
     * 自定义redis缓存超时等配置策略
     * @param template
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate template) {

        return RedisCacheManager.RedisCacheManagerBuilder
                // Redis 连接工厂
                .fromConnectionFactory(template.getConnectionFactory())
                .cacheDefaults(getCacheConfigurationWithTtl(template, 0)) // 默认缓存永不超时
                .withCacheConfiguration("gen_table", getCacheConfigurationWithTtl(template, 0))
                // 配置同步修改或删除 put/evict
                .transactionAware()
                .build();
    }
    private RedisCacheConfiguration getCacheConfigurationWithTtl(RedisTemplate template, long seconds) {
        return RedisCacheConfiguration
                .defaultCacheConfig()
                // 设置key为String
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(template.getStringSerializer()))
                // 设置value 为自动转Json的Object
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new FastJson2JsonRedisSerializer(Object.class)))
                // 不缓存null
                .disableCachingNullValues()
                // 变双冒号为单冒号
                .computePrefixWith(keyName -> keyName + ":")
                // 缓存数据超时时间
                .entryTtl(Duration.ofSeconds(seconds));

    }
}

2、RedisToken.java

src/main/java/com/inspur/common/core/redis/RedisCache.java

package com.inspur.common.core.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * spring redis 工具类，仅操作用户登录token
 *
 * @author Inspur
 **/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisTokenCache {
    @Autowired
    @Qualifier("tokenRedisTemplate")
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public  void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public  void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取有效时间
     *
     * @param key Redis键
     * @return 有效时间
     */
    public long getExpire(final String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public  T getCacheObject(final String key) {
        ValueOperations operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection) {
        return redisTemplate.delete(collection) > 0;
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public  long setCacheList(final String key, final List dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public  List getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public  BoundSetOperations setCacheSet(final String key, final Set dataSet) {
        BoundSetOperations setOperation = redisTemplate.boundSetOps(key);
        Iterator it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public  Set getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public  void setCacheMap(final String key, final Map dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public  Map getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public  void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public  T getCacheMapValue(final String key, final String hKey) {
        HashOperations opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public  List getMultiCacheMapValue(final String key, final Collection hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 删除Hash中的某条数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return 是否成功
     */
    public boolean deleteCacheMapValue(final String key, final String hKey) {
        return redisTemplate.opsForHash().delete(key, hKey) > 0;
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }


    /**
     * 通配符删除key
     *
     * @param key key值
     */
    public void deleteKey(final String key) {
        Collection keys = this.keys(key);
        redisTemplate.delete(keys);
    }
}



3、TokenService.java


package com.inspur.common.service;

import com.inspur.common.constant.Constants;
import com.inspur.common.core.domain.model.LoginUser;
import com.inspur.common.core.redis.RedisTokenCache;
import com.inspur.common.utils.ServletUtils;
import com.inspur.common.utils.StringUtils;
import com.inspur.common.utils.ip.AddressUtils;
import com.inspur.common.utils.ip.IpUtils;
import com.inspur.common.utils.uuid.IdUtils;
import eu.bitwalker.useragentutils.UserAgent;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * token验证处理
 *
 * @author Inspur
 */
@Component
public class TokenService
{
    // 令牌自定义标识
    @Value("${token.header}")
    private String header;

    // 令牌秘钥
    @Value("${token.secret}")
    private String secret;

    // 令牌有效期（默认30分钟）
    @Value("${token.expireTime}")
    private int expireTime;

    protected static final long MILLIS_SECOND = 1000;

    protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;

    private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;

    @Autowired
    private RedisTokenCache redisTokenCache;

    /**
     * 获取用户身份信息
     *
     * @return 用户信息
     */
    public LoginUser getLoginUser(HttpServletRequest request)
    {
        // 获取请求携带的令牌
        String token = getToken(request);
        if (StringUtils.isNotEmpty(token))
        {
            try
            {
                Claims claims = parseToken(token);
                // 解析对应的权限以及用户信息
                String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                String userKey = getTokenKey(uuid);
                LoginUser user = redisTokenCache.getCacheObject(userKey);
                return user;
            }
            catch (Exception e)
            {
            }
        }
        return null;
    }


    public LoginUser getLoginUser(String token) {
        if (StringUtils.isNotEmpty(token))
        {
            try
            {
                Claims claims = parseToken(token);
                // 解析对应的权限以及用户信息
                String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                String userKey = getTokenKey(uuid);
                LoginUser user = redisTokenCache.getCacheObject(userKey);
                return user;
            }
            catch (Exception e)
            {
            }
        }
        return null;
    }

    /**
     * 设置用户身份信息
     */
    public void setLoginUser(LoginUser loginUser)
    {
        if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken()))
        {
            refreshToken(loginUser);
        }
    }

    /**
     * 删除用户身份信息
     */
    public void delLoginUser(String token)
    {
        if (StringUtils.isNotEmpty(token))
        {
            String userKey = getTokenKey(token);
            redisTokenCache.deleteObject(userKey);
        }
    }

    /**
     * 创建令牌
     *
     * @param loginUser 用户信息
     * @return 令牌
     */
    public String createToken(LoginUser loginUser)
    {
        String token = IdUtils.fastUUID();
        loginUser.setToken(token);
        setUserAgent(loginUser);
        refreshToken(loginUser);

        Map claims = new HashMap<>();
        claims.put(Constants.LOGIN_USER_KEY, token);
        claims.put(Constants.JWT_USERID, loginUser.getUserId());
        claims.put(Constants.JWT_USERNAME, loginUser.getUsername());
        return createToken(claims);
    }

    /**
     * 验证令牌有效期，相差不足20分钟，自动刷新缓存
     *
     * @param loginUser
     * @return 令牌
     */
    public void verifyToken(LoginUser loginUser)
    {
        long expireTime = loginUser.getExpireTime();
        long currentTime = System.currentTimeMillis();
        if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
        {
            refreshToken(loginUser);
        }
    }

    /**
     * 刷新令牌有效期
     *
     * @param loginUser 登录信息
     */
    public void refreshToken(LoginUser loginUser)
    {
        loginUser.setLoginTime(System.currentTimeMillis());
        loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
        // 根据uuid将loginUser缓存
        String userKey = getTokenKey(loginUser.getToken());
        redisTokenCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
    }

    /**
     * 设置用户代理信息
     *
     * @param loginUser 登录信息
     */
    public void setUserAgent(LoginUser loginUser)
    {
        UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
        String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
        loginUser.setIpaddr(ip);
        loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
        loginUser.setBrowser(userAgent.getBrowser().getName());
        loginUser.setOs(userAgent.getOperatingSystem().getName());
    }

    /**
     * 从数据声明生成令牌
     *
     * @param claims 数据声明
     * @return 令牌
     */
    private String createToken(Map claims)
    {
        String token = Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS512, secret).compact();
        return token;
    }

    /**
     * 从令牌中获取数据声明
     *
     * @param token 令牌
     * @return 数据声明
     */
    private Claims parseToken(String token)
    {
        return Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
    }

    /**
     * 从令牌中获取用户名
     *
     * @param token 令牌
     * @return 用户名
     */
    public String getUsernameFromToken(String token)
    {
        Claims claims = parseToken(token);
        return claims.getSubject();
    }

    public LoginUser getLoginUserFromToken(String token)
    {
        if (StringUtils.isNotEmpty(token))
        {
            try
            {
                Claims claims = parseToken(token);
                // 解析对应的权限以及用户信息
                String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                String userKey = getTokenKey(uuid);
                LoginUser user = redisTokenCache.getCacheObject(userKey);
                return user;
            }
            catch (Exception e)
            {
            }
        }
        return null;
    }

    /**
     * 获取请求token
     *
     * @param request
     * @return token
     */
    private String getToken(HttpServletRequest request)
    {
        String token = request.getHeader(header);
        if (StringUtils.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX))
        {
            token = token.replace(Constants.TOKEN_PREFIX, "");
        }
        return token;
    }

    private String getTokenKey(String uuid)
    {
        return Constants.LOGIN_TOKEN_KEY + uuid;
    }

}



























你可能感兴趣的:(java,spring,redis)






    

  • String存储原理
程序员阿鹏
Java面试八股文javajvm开发语言eclipseintellij-idea后端

    1.是什么在Java中，String是一种特殊的类，它是不可变的并且存储在堆内存中。为了理解String的存储原理，我们需要分解几个关键概念：不可变性、堆内存、字符串常量池和垃圾回收机制。下面我将详细解释这些概念并举例说明。不可变性(Immutability)String类在Java中是不可变的，这意味着一旦创建了String对象，它的值就不能被修改。任何对String进行的修改操作，实际上都是创
    

    • 

  • JAVA常用校验注解
小卡车555
java

    引入依赖org.springframeworkspring-boot-starter-validation2.6.13相关注解及使用说明注解描述@AssertFalse所注解的元素必须是Boolean类型，且值为false@AssertTrue所注解的元素必须是Boolean类型，且值为true@DecimalMin验证Number和String对象是否大于等于指定的值，支持小数@DecimalM
    

    • 

  • 论文分享系列（二）——论微服务架构及其应用
马斯洛金字塔下的小灵猴儿
#软考高项架构师论微服务架构及其应用论文

    论微服务架构及其应用摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，将介绍微服务架构的特点、应用场景以及实现方法。系统以SpringCloud微服务框架开发，分为前端Web服务、平台保障服务、业务服务三部分。前端Web服务由负载均衡与服务器集群结合，实现高并发的前台界面；平台保障服务以Eureka为中心
    

    • 

  • Redisson分布式锁实现原理和使用
牧竹子
springboot#redisRedissonredis

    常见的锁内存锁lock,synchronize分布式锁redis，zookeeper实现Redisson基于redis实现了Lock接口的分布式集群锁，是可重入锁，功能强大，源码复杂，比redis单机模式分布式锁可靠，稳定性更高，支持集群模式，支持锁根据业务时长自动延迟释放redis普通分布式锁存在一定的缺陷——它加锁只作用在一个Redis节点上，如果通过sentinel和cluster保证高可用
    

    • 

  • 分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警)
yjjpp2301
Celery分布式djangopython后端

    Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
    

    • 

  • Spring Boot项目自动生成OpenAPI3.0规范的接口描述文档yaml
[email protected]
springbootjavaopenapi

    首先在pom.xml文件中添加springdoc-openapi的依赖：org.springdocspringdoc-openapi-core1.1.45启动SpringBoot程序，通过项目的ip和端口/v3/api-docs访问自动生成的OpenAPI3.0文档(JSON)/v3/api-docs.yaml下载yaml格式的文件如果想要自定义路径，可在application.propertie
    

    • 

  • java 线程池 队列封装_java线程池（线程池组---分离任务队列和线程池）
爱打怪的小魔女
java线程池队列封装

    线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/消费者”模型。生产消费外部线程(生产者)－－－>任务消费者和生产者共享一个数据结构(缓存任务)PriorityQueue；生产者将任务添加到队列中，消费者从队列中取出数据；队列和线程池(线程池内部维护一个线程数组)，完全耦合在一起，当任务特别多，队列就不断的膨胀，增多，拥堵；就向车子过洞子另外一头走不掉，我靠，长龙(世界最长堵车世界纪录在天朝2
    

    • 

  • 基于springboot+vue的“考研资讯平台”程序设计实现【毕业论文，源码】
一枚务实的码农
毕业设计毕设考研springboot毕业论文系统源码

    摘要随着现在网络的快速发展，网络的应用在各行各业当中它很快融入到了许多学校的眼球之中，他们利用网络来做这个电商的服务，随之就产生了“考研资讯平台”，这样就让学生考研资讯平台更加方便简单。对于本考研资讯平台的设计来说，它主要是采用java技术。在整个系统的设计当中它是应用mysql数据库来完成的，具体根据网上考研资讯平台的现状来进行开发的，具体根据学生需求实现网上考研资讯平台网络化的管理，各类信息有
    

    • 

  • 在 Spring Boot 项目中连接 IBM AS/400 数据库——详细案例教程
箬敏伊儿
数据库AS/400springboot数据库后端databasejava

    文章目录1.添加`jt400`依赖2.下载`jt400`驱动包依赖下载手动下载下载地址：手动下载JAR的步骤：3.配置application.properties或application.yml（1）`application.properties`（2）`application.yml`4.数据源配置类（可选）5.创建`JDBC`访问层6.测试连接7.启动项目总结在SpringBoot项目中连接I
    

    • 

  • String方法(JDK9)
凯哥学堂

    声明：本栏目所使用的素材都是凯哥学堂VIP学员所写，学员有权匿名，对文章有最终解释权；凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。String方法(JDK9)构造器：String#String()无参数构造器，默认给的是一个””空字符串String#String(java.lang.String)给你一个char数组，它就帮你进行ABCD输出GBK中文简体+繁体字符集GB2312中文简体字
    

    • 

  • 如果面试官问你CAS，你还这么答，可能就要回去等通知了
爱玛士
程序员面试Javajava面试开发语言程序员架构

    前言大家好，我是JAVA高级开发之路，一个总在为粉丝解决面试题的程序员。最近有几个粉丝说在面试面试中遇到了CAS的问题，连着几次面试都没有让面试官满意，区区CAS底层源码，怎能难倒咱们这届程序员们呢？都支棱起来，跟我一起来搞定CAS底层源码。什么是CASCAS的全称是Compare-And-Swap，它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原
    

    • 

  • Redis的持久化和高可用性
小辛学西嘎嘎
redis数据库缓存

    目录一、淘汰策略1、背景2、淘汰策略二、持久化1、背景2、fork进程写时复制机制3、Redis持久化方式1、aof2、rdb三、高可用1、主从复制2、Redis哨兵模式3、Rediscluster集群一、淘汰策略1、背景首先Redis是一个内存数据库，将所有数据存放在内存中，通过对K值进行hash后存储在散列表中。有一个小问题Redis数据库占96G，但为什么最终占满只有48G呢。因为中间有个过
    

    • 

  • springBoot 集成https
ourLang
javaspringboothttpsjava

    springBoot集成https1、springBoot默认的证书格式pringBoot需要.p12或.jks格式的证书。如果你只有.pem和.key文件，可以使用openssl工具将它们转换成.p12文件2、转换.p12我的证书文件如下，需要转换2.1下载opensslhttps://slproweb.com/download/Win64OpenSSL-3_3_2.exe2.2执行命令生成.p
    

    • 

  • 线程池的应用--＞1
路ZP
java开发语言

    1.线程的执行机制线程分为用户线程和内核线程内核线程就是系统级别的线程，与cpu逻辑处理器数量对应的用户线程就是使用java代码创建的Thread对象用户线程必须与内核线程关联（映射），才能执行任务当用户线程多于内核线程时，内核线程就需要不停的上下文切换，使得多个用户线程都能得以执行上下文会影响性能，消耗资源。大量的创建用户线程，消耗用户线程，也会影响性能，消耗资源。所以我们希望，创建合适数量的线
    

    • 

  • java mongodb group分组使用
yank1225
mongodbjavamongodbgroup

    mongodb的关键字及介绍.mongodb的查询是有一定规则的,刚开始接触老是各种错误,参照以下内容有很多帮助https://docs.mongodb.com/manual/reference/sql-aggregation-comparison/另外出现这种错误时Apipelinestagespecificationobjectmustcontainexactlyonefield是因为条件不对
    

    • 

  • Java中的大数据处理框架对比分析
省赚客app开发者
java开发语言

    Java中的大数据处理框架对比分析大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天，我们将深入探讨Java中常用的大数据处理框架，并对它们进行对比分析。大数据处理框架是现代数据驱动应用的核心，它们帮助企业处理和分析海量数据，以提取有价值的信息。本文将重点介绍ApacheHadoop、ApacheSpark、ApacheFlink和ApacheStorm这四种流行的
    

    • 

  • Java 学习路线：语言、框架、中间件与数据库
高危型
java

    Java是一门功能强大、应用广泛的编程语言，适用于企业级应用、Web开发、大数据处理、Android开发等各种场景。这里为大家介绍了一下我认为较为合适的学习路线一、Java基础1.1Java语言基础1.1.1安装JDK和IDE安装JDK：下载JDK：访问Oracle官网，下载最新的JavaDevelopmentKit（JDK）。安装JDK：按照操作系统要求安装JDK并配置环境变量。Windows上
    

    • 

  • SpringSecurity认证鉴权流程
JH3073
服务器java前端

    SpringSecurity认证鉴权流程SpringSecurity的认证流程SpringSecurity的鉴权流程将用户交给SpringSecurity管理主要涉及以下几个步骤：SpringSecurity的认证流程用户请求：用户向应用程序发起请求，通常是访问受保护的资源（例如，一个需要登录的页面）。检查是否需要认证：SpringSecurity会检查请求的URL是否需要认证。这个检查是基于配置
    

    • 

  • Java 入门基础篇05 - Java的关键字
仔仔 v1.0
Java基础java开发语言intellij-idea

    什么是关键字？就是被java语言赋予特殊含义的单词。关键字的特点组成关键的字母都是小写。常见关键字class,public,static,void.....。关键字注意事项goto和const是java语言的保留字，关键字在IDEA编译器中有明确的颜色变化。关键字列表ABSTRACTCONTINUEFORNEWSWITCHassertdefaultgotopackagesynchronizedbo
    

    • 

  • Java服务端中的性能监控：Prometheus与Grafana的集成
微赚淘客系统@聚娃科技
javaprometheusgrafana

    Java服务端中的性能监控：Prometheus与Grafana的集成大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在构建和维护Java服务端应用时，性能监控是确保系统稳定性和性能的重要环节。Prometheus与Grafana是当前最流行的性能监控工具组合之一，能够提供强大的数据采集、存储和可视化功能。本文将介绍如何在Java服务端中集成Prometheus与
    

    • 

  • Json格式化
微赚淘客系统@聚娃科技
json

    Json格式化大家好，我是微赚淘客机器人的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！Json格式化：让数据更亮眼，解密Json的奇妙世界在现代Web开发中，Json（JavaScriptObjectNotation）已经成为数据交换的标准之一。然而，对于人眼来说，一串紧凑的Json字符串并不直观，而经过格式化处理后的Json却如同一幅清晰的画面。本文将深入探讨Json格式化的重要性、实现方法以
    

    • 

  • NoClassDefFoundError: org.apache.poi.POIXMLDocument问题排查解决
qinmingjun718
apache

    java.lang.NoClassDefFoundError:org/apache/poi/POIXMLDocumentPart这错很明显就是没找到这个类POIXMLDocumentPart就是找不到类问题原因是大概是因为poi从3.1.X低版本版本升级到pio4.1.2高版本的后与org.apache.poi.xwpf.converter.core-1.0.6.jar不兼容问题，导致这个情况的主
    

    • 

  • 设背包密码系统的超递增序列为A=（3，4，9，17，35），乘数t=19，模数k=73，试对good night加密
CHENGlady
密码学密码学背包密码

    PS:后续在此基础上更新Java代码1.超递增序列含义超递增序列是指一个正整数序列，其中每个元素a[i]（i≥2）都大于它前面所有元素之和，即a[i]>（a[1]+a[2]+...+a[i-1]）2.加密公式C=（B*）modkC是明文组3.求B公式：B≡t*Amodk解释：B：是通过私钥（一个超递增序列）和某个模数和乘数进行模乘运算得到的序列，以此作为公钥t:乘数A:题目给出的超递增序列k:模数
    

    • 

  • 基于nodejs+vue的美妆彩妆网站的设计与实现(源码+LW+调试文档+讲解等)
程序员gelei
nodejs毕业设计项目vue.js前端javascript

    目录：博主介绍：完整视频演示：系统技术介绍：后端Java介绍前端框架Vue介绍具体功能截图：部分代码参考：Mysql表设计参考：项目测试：项目论文：为什么选择我：源码获取：博主介绍：博主：程序员gelei：全网拥有20W+粉丝、CSDN作者、博客专家、全栈领域优质创作者、平台优质Java创作者、专注于Java、小程序、python、安卓技术领域和毕业项目实战✌Java精品实战案例《1000套》20
    

    • 

  • 【保姆级】使用Java注解和反射实现JSON字段自动重命名
AQin1012
Java出坑必备~java注解后端开发语言

    不知道有没有同学遇到过对接业务方代码非常“独具一格”（不符合通用规范且不愿意配合修改emmmm。。。），于是就只能“被迫”按他的格式来，但是又不想因为他的不规范导致我们自己创建的接收对象也非常的“一言难尽”。。。今天这篇帮你解决这个问题~（老规矩：附完整可执行代码）先给初学Java的同学补下基础，涉及到一些实现这个功能需要的知识点（了解的朋友可以直接跳过~）Java注解（Annotation）Ja
    

    • 

  • 使用poi替换XWPFTableCell内容，并设置行间距
RR369_yyh
javaUtiljavapoi

    使用poi读取word文档（docx类型），进行数据替换。另外，为了记录poi设置行间距的api，真是找了好几十分钟才找到啊啊啊啊！！！importorg.apache.poi.xwpf.usermodel.*;importorg.springframework.util.StringUtils;importjava.io.File;importjava.io.FileInputStream;im
    

    • 

  • 【数据结构和算法实践-树-LeetCode110-平衡二叉树】
NeVeRMoRE_2024
数据结构与算法实践算法数据结构leetcodeb树

    数据结构和算法实践-树-LeetCode110-平衡二叉树题目MyThought代码示例JAVA-8题目给定一个二叉树，判断它是否是平衡二叉树输入：root=[3,9,20,null,null,15,7]输出：trueMyThought判断平衡二叉树的条件是树的左右高度相差为1一、利用递归去遍历1、边界为节点为null，树高为0；2、树高的递增规则为，根的左节点和右节点比较值+1二、为了方便信息传
    

    • 

  • Apache POI用法
JH3073
apache

    一、ApachePOI是什么ApachePOI是用Java编写的免费开源的跨平台的JavaAPI，ApachePOI提供API给Java程序对MicrosoftOffice格式档案读和写的功能，其中使用最多的就是使用POI操作Excel文件。二、POI结构HSSF－提供读写MicrosoftExcelXLS格式档案的功能XSSF－提供读写MicrosoftExcelOOXMLXLSX格式档案的功能
    

    • 

  • idea自动下载gradle_解决 IDEA 导入 Gradle 项目默认下载 Gradle.zip 失败
weixin_39730671
idea自动下载gradle

    这几天打算看看Spring-Framework的源码，于是将Spring-Framework的源码从GitHub拉到了Gitee，然后从Gitee上面下载到本地，几经波折终于下载到本地了。欣喜若狂的打开IDEA，Open了这个刚下载好的源码项目，结果一打开项目，它便自己开始下载起了gradle-6.5.1-bin.zip，下载了老半天都没啥动静，最后还直接给超时失败了。本来以前也不这样啊，我记得之
    

    • 

  • Python+Django毕业设计校园易购二手交易平台（程序+LW+部署）
Python、JAVA毕设程序源码
课程设计javamysql

    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
    

    • 

  • 算法 单链的创建与删除
换个号韩国红果果
c算法

    
先创建结构体
struct student {
int data;
//int tag;//标记这是第几个
struct student *next;
};
// addone 用于将一个数插入已从小到大排好序的链中
struct student *addone(struct student *h,int x){
if(h==NULL) //??????

    

    • 

  • 《大型网站系统与Java中间件实践》第2章读后感
白糖_
java中间件

           断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。
 
       看完整章内容，
    

    • 

  • zeus持久层spring事务单元测试
deng520159
javaDAOspringjdbc

    今天把zeus事务单元测试放出来,让大家指出他的毛病,
1.ZeusTransactionTest.java 单元测试
 
package com.dengliang.zeus.webdemo.test;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import 
    

    • 

  • Rss 订阅 开发
周凡杨
htmlxml订阅rss规范

     
              RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。
 
RSS
    

    • 

  • 分页查询实现
g21121
分页查询

    在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。
按实现形式分前台分页和服务器分页：
前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。
服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
    

    • 

  • spring jms异步消息处理
510888780
jms

    spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下： 
    

    • 

  • highCharts柱状图
布衣凌宇
hightCharts柱图

    第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller
 
@Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController {  private UserServi
    

    • 

  • 我的spring学习笔记2-IoC（反向控制 依赖注入）
aijuans
springmvcSpring 教程spring3 教程Spring 入门

    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
    

    • 

  • TLS java简单实现
antlove
javasslkeystoretlssecure

     
1. SSLServer.java
package ssl;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.KeyStore;
import 
    

    • 

  • Zip解压压缩文件
百合不是茶
Zip格式解压Zip流的使用文件解压

     
 ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件;
ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName));
 
 
&n
    

    • 

  • underscore.js 学习（一）
bijian1013
JavaScriptunderscore

            工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。       学
    

    • 

  • java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon)
bijian1013
javajvmjstatd

    1.介绍
        jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。
        jstatd是基于RMI的，所以在运行jstatd的服务
    

    • 

  • 【Spring框架三】Spring常用注解之Transactional
bit1129
transactional

    Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义：
 
/*
* Copyright 2002-2010 the original author or authors.
*
* Licensed under the Apache License, Version 
    

    • 

  • 我(程序员)的前进方向
bitray
程序员

    作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
    

    • 

  • nginx lua开发经验总结
ronin47

    使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下 1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
    

    • 

  • java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶
bylijinnan
java

    
import java.util.Stack;
public class ReverseStackRecursive {
/**
* Q 66.颠倒栈。
* 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。
* 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。
*1. Pop the top element
*2. Revers
    

    • 

  • 正确理解Linux内存占用过高的问题
cfyme
linux

    Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上：
Mem:   3889836k total,  3341868k used,   547968k free,   286044k buffers
Swap:  6127608k total,&nb
    

    • 

  • [JWFD开源工作流]当前流程引擎设计的一个急需解决的问题
comsci
工作流

    
     当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。
      而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
    

    • 

  • 自定义类的equals函数
dai_lm
equals

    仅作笔记使用
public class VectorQueue {
private final Vector<VectorItem> queue;
private class VectorItem {
private final Object item;
private final int quantity;
public VectorI
    

    • 

  • Linux下安装R语言
datageek
R语言 linux

    命令如下：sudo gedit  /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
    

    • 

  • 如何修改mysql 并发数(连接数)最大值
dcj3sjt126com
mysql

    MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了
 
方法一：进入MYSQL安装目录 打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可
　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
    

    • 

  • 单一功能原则
dcj3sjt126com
面向对象的程序设计软件设计编程原则

    单一功能原则[
编辑]    
SOLID 原则
单一功能原则
开闭原则
Liskov代换原则
接口隔离原则
依赖反转原则
查  
论  
编
在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
    

    • 

  • POJO、VO和JavaBean区别和联系
fanmingxing
VOPOJOjavabean

    POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
    

    • 

  • SpringSecurity3.X--LDAP：AD配置
hanqunfeng
SpringSecurity

    前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。
 
将配置文件中的如下部分删除：
<!-- 认证管理器，使用自定义的UserDetailsService，并对密码采用md5加密-->

    

    • 

  • mac mysql 修改密码
IXHONG
mysql

    $ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
    

    • 

  • 设计模式--抽象工厂模式
kerryg
设计模式

    抽象工厂模式：
    工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
    总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
    

    • 

  • 评"高中女生军训期跳楼”
nannan408

       首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。
   孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
    

    • 

  • scala如何读取和写入文件内容？
qindongliang1922
javajvmscala

    直接看如下代码：
package file
import java.io.RandomAccessFile
import java.nio.charset.Charset
import scala.io.Source
import scala.reflect.io.{File, Path}
/**
* Created by qindongliang on 2015/
    

    • 

  • C语言算法之百元买百鸡
qiufeihu
c算法

    中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？
代码如下：
#include <stdio.h>
int main()
{
int cock,hen,chick; /*定义变量为基本整型*/
for(coc
    

    • 

  • Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode
wyz2009107220
NameNode

    正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。
1. Secondary NameNode
原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image
优点：Hadoop较早的版本都自带，
    

    •