沐沐女神
沐沐女神

1.springcloud微服务架构搭建 之 《springboot自动装配Redis》

背景：由于自研框架，好多公司都自己封装自己的Redis，所以需要单独讲redis封装起来，作为公举模块给业务系统用。自动装配原理就不介绍了，网上一搜一大堆，说的都不错。废话不多数，上代码

目录

项目结构：

1.springboot 版本号选择

 2.项目根pom配置 lilock-framework

3.公共模块pom配置 lilock-commons

4.redis模块pom配置  lilock-redis-spring-boot-starter

        4.1 自定义redis参数配置类

        4.2 自定义redis工具类 RedisService

        4.3 自定义redis配置类

        4.4 springboot装配文件 spring.factories

5.新建lilock-server-user模块 

        5.1 application.yml配置redis参数

         5.2 新建测试类

        5.3 测试结果

项目结构：

lilock-framework
    lilock-commons
        lilock-common-spring-boot-starter
        lilock-redis-spring-boot-starter
    lilock-modules
        lilock-service-user

1.springboot 版本号选择

我自己选定的版本号是 2.3.12.RELEASE，可以根据自己公司对springboot的版本号情况自己选定


    org.springframework.boot
    spring-boot-starter-parent
    2.3.12.RELEASE

 2.项目根pom配置 lilock-framework



    4.0.0
    
        lilock-commons
        lilock-modules

    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.12.RELEASE
    
    lilock.cn
    lilock-framework
    1.0-SNAPSHOT
    lilock-framework
    pom
    
        8
        2.3.12.RELEASE
        1.18.26
        2.14.2
        3.8.0
        2.9.2
        1.2.70
        2.1.0.RELEASE
    

    
        
            
                org.springframework.boot
                spring-boot-starter-web
                ${spring.boot.version}
            
            
                org.springframework.boot
                spring-boot-starter-test
                ${spring.boot.version}
            
            
                org.springframework.boot
                spring-boot-autoconfigure
                ${spring.boot.version}
            
            
                org.springframework.boot
                spring-boot-starter-data-redis
                ${spring.boot.version}
            
            
                org.springframework.boot
                spring-boot-configuration-processor
                ${spring.boot.version}
            
            
                io.springfox
                springfox-swagger-ui
                ${swagger.version}
            
            
            
                com.alibaba
                fastjson
                ${fastjson.version}
            
            
                io.springfox
                springfox-swagger2
                ${swagger.version}
            
            
            
                redis.clients
                jedis
                ${jedis.version}
            
            
                org.projectlombok
                lombok
                ${lombok.version}
            
            
            
                com.fasterxml.jackson.core
                jackson-core
                ${jackson.version}
            
            
                com.fasterxml.jackson.core
                jackson-annotations
                ${jackson.version}
            
            
                com.fasterxml.jackson.core
                jackson-databind
                ${jackson.version}
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

3.公共模块pom配置 lilock-commons



    
        lilock-framework
        lilock.cn
        1.0-SNAPSHOT
    
    4.0.0

    lilock-commons
    pom
    
        lilock-redis-spring-boot-starter

4.redis模块pom配置  lilock-redis-spring-boot-starter



    
        lilock-commons
        lilock.cn
        1.0-SNAPSHOT
        
    
    4.0.0
    lilock-common-spring-redis-starter
    
        
            org.springframework.boot
            spring-boot-autoconfigure
        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.springframework.boot
            spring-boot-configuration-processor
        
        
            redis.clients
            jedis
        
        
            com.alibaba
            fastjson
        
        
            org.projectlombok
            lombok
        
        
            com.fasterxml.jackson.core
            jackson-core
        

        
            com.fasterxml.jackson.core
            jackson-annotations
        
        
            com.fasterxml.jackson.core
            jackson-databind
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            
                            org.springframework.boot
                            spring-boot-configuration-processor

上述配置Redis自动装配模块的所有配置，开始进入主题

        4.1 自定义redis参数配置类

package lilock.cn.common.redis.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@Data
@ConfigurationProperties(prefix = "lilock.redis")
public class RedisDataSourceProperties {

    //链接地址
    private String host;

    //端口号
    private Integer port;

    //默认database
    private Integer database;

    //密码
    private String password;

    //超时时间
    private Integer timeout;

    //最大空闲数
    private Integer maxIdle;

    //连接池最大连接数
    private Integer maxTotal;

    //最大等待时间
    private Integer maxWaitMillis;

    //逐出链接最小空闲时间
    private Integer minEvictableIdleTimeMillis;

    //每次最大逐出数量
    private Integer numTestsPerEvictionRun;

    //逐出扫描时间的间隔
    private Long timeBetweenEvictionRunsMillis;

    ///是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    private boolean testOnBorrow;

    //空闲时检查有效性
    private boolean testWhileIdle;
}

        4.2 自定义redis工具类 RedisService

package lilock.cn.common.redis.template;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.RedisClusterNode;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisServerCommands;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.CollectionUtils;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Redis Repository
 * redis 基本操作 可扩展,基本够用了
 *
 */
@Slf4j
public class RedisService {
    /**
     * 默认编码
     */
    private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;

    /**
     * key序列化
     */
    private static final StringRedisSerializer STRING_SERIALIZER = new StringRedisSerializer();

    /**
     * value 序列化
     */
    private static final JdkSerializationRedisSerializer OBJECT_SERIALIZER = new JdkSerializationRedisSerializer();

    /**
     * Spring Redis Template
     */
    private RedisTemplate redisTemplate;




    public RedisService(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.redisTemplate.setKeySerializer(STRING_SERIALIZER);
        this.redisTemplate.setValueSerializer(OBJECT_SERIALIZER);
    }

    /**
     * 获取链接工厂
     */
    public RedisConnectionFactory getConnectionFactory() {
        return this.redisTemplate.getConnectionFactory();

    }

    /**
     * 获取 RedisTemplate对象
     */
    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }

    /**
     * 清空DB
     *
     * @param node redis 节点
     */
    public void flushDB(RedisClusterNode node) {
        this.redisTemplate.opsForCluster().flushDb(node);
    }

    /**
     * 添加到带有 过期时间的  缓存
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间(单位秒)
     */
    public void setExpire(final byte[] key, final byte[] value, final long time) {
        redisTemplate.execute((RedisCallback) connection -> {
            connection.setEx(key, time, value);
            log.debug("[redisTemplate redis]放入 缓存  url:{} ========缓存时间为{}秒", key, time);
            return 1L;
        });
    }

    /**
     * 添加到带有 过期时间的  缓存
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间(单位秒)
     */
    public void setExpire(final String key, final Object value, final long time) {
        redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = OBJECT_SERIALIZER.serialize(value);
            boolean f = connection.setEx(keys, time, values);
            log.info("[redisTemplate redis]放入 缓存  url:{} ========缓存时间为{}秒,{}", key, time, f);
            return 1L;
        });
    }

    /**
     * 一次性添加数组到   过期时间的  缓存，不用多次连接，节省开销
     *
     * @param keys   redis主键数组
     * @param values 值数组
     * @param time   过期时间(单位秒)
     */
    public void setExpire(final String[] keys, final Object[] values, final long time) {
        redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            for (int i = 0; i < keys.length; i++) {
                byte[] bKeys = serializer.serialize(keys[i]);
                byte[] bValues = OBJECT_SERIALIZER.serialize(values[i]);
                connection.setEx(bKeys, time, bValues);
            }
            return 1L;
        });
    }


    /**
     * 一次性添加数组到   过期时间的  缓存，不用多次连接，节省开销
     *
     * @param keys   the keys
     * @param values the values
     */
    public void set(final String[] keys, final Object[] values) {
        redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            for (int i = 0; i < keys.length; i++) {
                byte[] bKeys = serializer.serialize(keys[i]);
                byte[] bValues = OBJECT_SERIALIZER.serialize(values[i]);
                connection.set(bKeys, bValues);
            }
            return 1L;
        });
    }


    /**
     * 添加到缓存
     *
     * @param key   the key
     * @param value the value
     */
    public void set(final String key, final Object value) {
        redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = OBJECT_SERIALIZER.serialize(value);
            connection.set(keys, values);
            log.debug("[redisTemplate redis]放入 缓存  url:{}", key);
            return 1L;
        });
    }

    /**
     * 查询在这个时间段内即将过期的key
     *
     * @param key  the key
     * @param time the time
     * @return the list
     */
    public List willExpire(final String key, final long time) {
        final List keysList = new ArrayList<>();
        redisTemplate.execute((RedisCallback>) connection -> {
            Set keys = redisTemplate.keys(key + "*");
            for (String key1 : keys) {
                Long ttl = connection.ttl(key1.getBytes(DEFAULT_CHARSET));
                if (0 <= ttl && ttl <= 2 * time) {
                    keysList.add(key1);
                }
            }
            return keysList;
        });
        return keysList;
    }


    /**
     * 查询在以keyPatten的所有  key
     *
     * @param keyPatten the key patten
     * @return the set
     */
    public Set keys(final String keyPatten) {
        return redisTemplate.execute((RedisCallback>) connection -> redisTemplate.keys(keyPatten + "*"));
    }
    
    /**
     * 利用scan 查询 keyPattern关键字的key集合
     * @param keyPattern
     * @return
     */
    public Set scan(final String keyPattern) {
        Set keys = redisTemplate.execute((RedisCallback>) connection -> {
            Set keysTmp = new HashSet<>();
            Cursor cursor = connection.scan(KeyScanOptions.scanOptions().match( keyPattern + "*").count(1000).build());
            while (cursor.hasNext()) {
                keysTmp.add(new String(cursor.next()));
            }
            return keysTmp;
        });
        return keys;
    }

    /**
     * 根据key获取对象
     *
     * @param key the key
     * @return the byte [ ]
     */
    public byte[] get(final byte[] key) {
        byte[] result = redisTemplate.execute((RedisCallback) connection -> connection.get(key));
        log.debug("[redisTemplate redis]取出 缓存  url:{} ", key);
        return result;
    }

    /**
     * 根据key获取对象
     *
     * @param key the key
     * @return the string
     */
    public Object get(final String key) {
        Object resultStr = redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = connection.get(keys);
            return OBJECT_SERIALIZER.deserialize(values);
        });
        log.debug("[redisTemplate redis]取出 缓存  url:{} ", key);
        return resultStr;
    }


    /**
     * 根据key获取对象
     *
     * @param keyPatten the key patten
     * @return the keys values
     */
    public Map getKeysValues(final String keyPatten) {
        log.debug("[redisTemplate redis]  getValues()  patten={} ", keyPatten);
        return redisTemplate.execute((RedisCallback>) connection -> {
            RedisSerializer serializer = getRedisSerializer();
            Map maps = new HashMap<>(16);
            Set keys = redisTemplate.keys(keyPatten + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                for (String key : keys) {
                    byte[] bKeys = serializer.serialize(key);
                    byte[] bValues = connection.get(bKeys);
                    Object value = OBJECT_SERIALIZER.deserialize(bValues);
                    maps.put(key, value);
                }
            }
            return maps;
        });
    }

    /**
     * Ops for hash hash operations.
     *
     * @return the hash operations
     */
    public HashOperations opsForHash() {
        return redisTemplate.opsForHash();
    }

    /**
     * 对HashMap操作
     *
     * @param key       the key
     * @param hashKey   the hash key
     * @param hashValue the hash value
     */
    public void putHashValue(String key, String hashKey, Object hashValue) {
        log.debug("[redisTemplate redis]  putHashValue()  key={},hashKey={},hashValue={} ", key, hashKey, hashValue);
        opsForHash().put(key, hashKey, hashValue);
    }

    /**
     * 获取单个field对应的值
     *
     * @param key     the key
     * @param hashKey the hash key
     * @return the hash values
     */
    public Object getHashValues(String key, String hashKey) {
        log.debug("[redisTemplate redis]  getHashValues()  key={},hashKey={}", key, hashKey);
        return opsForHash().get(key, hashKey);
    }

    /**
     * 根据key值删除
     *
     * @param key      the key
     * @param hashKeys the hash keys
     */
    public void delHashValues(String key, Object... hashKeys) {
        log.debug("[redisTemplate redis]  delHashValues()  key={}", key);
        opsForHash().delete(key, hashKeys);
    }

    /**
     * key只匹配map
     *
     * @param key the key
     * @return the hash value
     */
    public Map getHashValue(String key) {
        log.debug("[redisTemplate redis]  getHashValue()  key={}", key);
        return opsForHash().entries(key);
    }

    /**
     * 批量添加
     *
     * @param key the key
     * @param map the map
     */
    public void putHashValues(String key, Map map) {
        opsForHash().putAll(key, map);
    }

    /**
     * 集合数量
     *
     * @return the long
     */
    public long dbSize() {
        return redisTemplate.execute(RedisServerCommands::dbSize);
    }

    /**
     * 清空redis存储的数据
     *
     * @return the string
     */
    public String flushDB() {
        return redisTemplate.execute((RedisCallback) connection -> {
            connection.flushDb();
            return "ok";
        });
    }

    /**
     * 判断某个主键是否存在
     *
     * @param key the key
     * @return the boolean
     */
    public boolean exists(final String key) {
        return redisTemplate.execute((RedisCallback) connection -> connection.exists(key.getBytes(DEFAULT_CHARSET)));
    }


    /**
     * 删除key
     *
     * @param keys the keys
     * @return the long
     */
    public long del(final String... keys) {
        return redisTemplate.execute((RedisCallback) connection -> {
            long result = 0;
            for (String key : keys) {
                result = connection.del(key.getBytes(DEFAULT_CHARSET));
            }
            return result;
        });
    }

    /**
     * 获取 RedisSerializer
     *
     * @return the redis serializer
     */
    protected RedisSerializer getRedisSerializer() {
        return redisTemplate.getStringSerializer();
    }

    /**
     * 对某个主键对应的值加一,value值必须是全数字的字符串
     *
     * @param key the key
     * @return the long
     */
    public long incr(final String key) {
        return redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer redisSerializer = getRedisSerializer();
            return connection.incr(redisSerializer.serialize(key));
        });
    }
    
    /**
     * 对某个主键对应的值减一,value值必须是全数字的字符串
     *
     * @param key the key
     * @return the long
     */
    public long decr(final String key) {
        return redisTemplate.execute((RedisCallback) connection -> {
            RedisSerializer redisSerializer = getRedisSerializer();
            return connection.decr(redisSerializer.serialize(key));
        });
    }

    /**
     * redis List 引擎
     *
     * @return the list operations
     */
    public ListOperations opsForList() {
        return redisTemplate.opsForList();
    }

    /**
     * redis set
     * @return
     */
    public SetOperations opsForSet(){
        return redisTemplate.opsForSet();
    }

    /**
     * //集合中添加元素，返回添加个数
     * @param setkeyName
     * @param value
     * @return
     */
    public Long addToSet(String setkeyName, String... value){
        Long addNum = redisTemplate.opsForSet().add(setkeyName, value);
        return addNum;
    }

    /**
     * 获取集合大小
     * @param setKeyName
     * @return
     */
    public Long getSetSize(String setKeyName){
        return redisTemplate.opsForSet().size(setKeyName);
    }

    /**
     * 获取所有的元素
     * @param setKeyName
     * @return
     */
    public Set getSetMember(String setKeyName){
        Set members = redisTemplate.opsForSet().members(setKeyName);
        return members;
    }

    /**
     * 从集合中删除指定元素
     * @param setkeyName
     * @param value
     * @return
     */
    public Long removeFromSet(String setkeyName, String value){
        Long removeNum = redisTemplate.opsForSet().remove(setkeyName, value);
        return removeNum;
    }

    /**
     * //判断集合中是否存在某元素
     * @param setkeyName
     * @param value
     * @return
     */
    public boolean isHaveFromSet(String setkeyName, String value){
        return redisTemplate.opsForSet().isMember(setkeyName, value);
    }

    /**
     * redis List数据结构 : 将一个或多个值 value 插入到列表 key 的表头
     *
     * @param key   the key
     * @param value the value
     * @return the long
     */
    public Long leftPush(String key, Object value) {
        return opsForList().leftPush(key, value);
    }

    /**
     * redis List数据结构 : 移除并返回列表 key 的头元素
     *
     * @param key the key
     * @return the string
     */
    public Object leftPop(String key) {
        return opsForList().leftPop(key);
    }

    /**
     * redis List数据结构 :将一个或多个值 value 插入到列表 key 的表尾(最右边)。
     *
     * @param key   the key
     * @param value the value
     * @return the long
     */
    public Long in(String key, Object value) {
        return opsForList().rightPush(key, value);
    }

    /**
     * redis List数据结构 : 移除并返回列表 key 的末尾元素
     *
     * @param key the key
     * @return the string
     */
    public Object rightPop(String key) {
        return opsForList().rightPop(key);
    }


    /**
     * redis List数据结构 : 返回列表 key 的长度 ; 如果 key 不存在，则 key 被解释为一个空列表，返回 0 ; 如果 key 不是列表类型，返回一个错误。
     *
     * @param key the key
     * @return the long
     */
    public Long length(String key) {
        return opsForList().size(key);
    }


    /**
     * redis List数据结构 : 根据参数 i 的值，移除列表中与参数 value 相等的元素
     *
     * @param key   the key
     * @param i     the
     * @param value the value
     */
    public void remove(String key, long i, Object value) {
        opsForList().remove(key, i, value);
    }

    /**
     * redis List数据结构 : 将列表 key 下标为 index 的元素的值设置为 value
     *
     * @param key   the key
     * @param index the index
     * @param value the value
     */
    public void set(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }

    /**
     * redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
     *
     * @param key   the key
     * @param start the start
     * @param end   the end
     * @return the list
     */
    public List getList(String key, int start, int end) {
        return opsForList().range(key, start, end);
    }

    /**
     * redis List数据结构 : 批量存储
     *
     * @param key  the key
     * @param list the list
     * @return the long
     */
    public Long leftPushAll(String key, List list) {
        return opsForList().leftPushAll(key, list);
    }

    /***
     * redis List数据结构：批量存储列表信息
     * @param key
     * @param list
     * @return
     */
    public Long rightPushAllObj(String key, List list) {
        return opsForList().rightPushAll(key,list);
    }

    /**
     * redis List数据结构 : 将值 value 插入到列表 key 当中，位于值 index 之前或之后,默认之后。
     *
     * @param key   the key
     * @param index the index
     * @param value the value
     */
    public void insert(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }


    /**
     * 设置缓存
     *
     * @param key   key
     * @param value value 存储结果是string，不是16进制
     * @param time  time大于0,则设置过期时间，否则不设置过期时间
     * @return
     */
    public boolean set(String key, String value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                redisTemplate.opsForValue().set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取key对应的value  value 为String
     *
     * @param key key
     * @return
     */
    public String getStrValue(String key) {
        if(key == null){
            return null;
        }
        Object value = redisTemplate.opsForValue().get(key);
        if(null != value){
            return (String)value;
        }else{
            return null;
        }
    }

    /***
     * 设置key 的过期时间
     * @param key
     * @param time
     * @param unit
     */
    public void expireAt(String key,Long time,TimeUnit unit){
        redisTemplate.expire(key,time,unit);
    }

    /**
     * 设置位图
     * @param key key
     * @param offSet 偏移量
     * @param flag true为1 false为0
     */
    public void setBit(String key, Long offSet, boolean flag) {
        redisTemplate.opsForValue().setBit(key, offSet, flag);
    }

    /**
     * 获取位图
     * @param key key
     * @param offSet 偏移量
     */
    public boolean getBit(String key, Long offSet) {
        return redisTemplate.opsForValue().getBit(key, offSet);
    }

    /**
     * 获取指定key的value为1的数量
     * @param key
     * @return
     */
    public Long bitCount(String key) {
        return redisTemplate.execute((RedisCallback) con -> con.bitCount(key.getBytes()));
    }

    /**
     * 获取key的过期时间
     * @param key
     * @return
     */
    public Long getExpire(String key) {
        return redisTemplate.opsForValue().getOperations().getExpire(key);
    }

    /**
     *
     * @param completeKey
     * @param bitmapKey
     * @param value
     * @return
     */
    public Long setLoginByLua(String completeKey, String bitmapKey, String value, Integer loginCount) {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setLocation(new ClassPathResource("redisSetLogin.lua"));
        redisScript.setResultType(String.class);

        //logincount转为string是因为StringRedisSerializer
        String result = redisTemplate.execute(redisScript, new StringRedisSerializer(), new StringRedisSerializer(),
                Arrays.asList(completeKey, bitmapKey), value, String.valueOf(loginCount));
        Long count = bitCount(bitmapKey);
        log.info("登录统计，KEY：{}，人数：{}",bitmapKey,count);
        return Long.valueOf(result);
    }

    /**
     * 设置位图偏移量的value为0
     * @param bitmapKey 位图key
     * @param offset 偏移量
     */
    public void setBitmap(String bitmapKey, String offset) {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setLocation(new ClassPathResource("redisSetBit.lua"));
        redisScript.setResultType(Long.class);
        redisTemplate.execute(redisScript, new StringRedisSerializer(), new StringRedisSerializer(),
                Arrays.asList(bitmapKey), offset);
    }
}
 
  
        4.3 自定义redis配置类
 
  
package lilock.cn.common.redis.config;

import com.alibaba.fastjson.JSONObject;
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 lilock.cn.common.redis.properties.RedisDataSourceProperties;
import lilock.cn.common.redis.template.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
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.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;
import redis.clients.jedis.JedisPoolConfig;

import java.lang.reflect.Method;
import java.time.Duration;


/**
 * redis 配置流程
 * 1.通过yaml 或者properties配置文件获取对应的redis的相关参数
 * 2.利用redis相关参数配置连接池
 * 2.利用连接池配置链接工厂
 * 3.利用链接工厂设置Redistemplate，设置key 和 value的序列化方式
 * 4.封装redis工具，利用redistemplate跟redis交互
 */
@EnableConfigurationProperties
@EnableCaching //开启SpringCache 管理
@Slf4j
public class RedisConfig extends CachingConfigurerSupport {
    @Autowired
    private RedisDataSourceProperties redisDataSourceProperties;
    /**
     * 配置key的生成策略
     * @return
     */
    @Bean
    public KeyGenerator keyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(":");
                sb.append(method.getName());
                sb.append(":");
                for (Object param : params) {
                    sb.append(param.toString());
                }
                return sb.toString();
            }
        };
    }


    /**
     * 配置jedis连接池
     * @return
     */
    @Bean("jedisPool")
    @Primary
    public JedisPoolConfig jedisPoolConfig(){
        //创建链接池
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //获取最大空闲数
        jedisPoolConfig.setMaxIdle(redisDataSourceProperties.getMaxIdle());
        //连接池最大连接数量
        jedisPoolConfig.setMaxTotal(redisDataSourceProperties.getMaxTotal());
        //连接池最大等待时间
        //jedisPoolConfig.setMaxWait(Duration.ofSeconds(redisDataSourceProperties.getMaxTotal()));
        //逐出链接最小空闲时间
        //jedisPoolConfig.setMinEvictableIdleTime(Duration.ofSeconds(redisDataSourceProperties.getMinEvictableIdleTimeMillis()));
        //每次逐出最大数量
        jedisPoolConfig.setNumTestsPerEvictionRun(redisDataSourceProperties.getNumTestsPerEvictionRun());
        //逐出扫描时间间隔
        //jedisPoolConfig.setTimeBetweenEvictionRuns(Duration.ofSeconds(redisDataSourceProperties.getTimeBetweenEvictionRunsMillis()));
        //是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
        jedisPoolConfig.setTestOnBorrow(redisDataSourceProperties.isTestOnBorrow());
        //空闲检查失效性
        jedisPoolConfig.setTestWhileIdle(redisDataSourceProperties.isTestWhileIdle());
        log.info("项目启动加载Redis连接池信息:{}", JSONObject.toJSONString(redisDataSourceProperties));
        return jedisPoolConfig;
    }

    /**
     * 初始化RedisTemplate的配置，配置序列化and工厂
     * @param jedisPoolConfig
     * @return
     */
    @Bean("jedisConnectionFactory")
    @Primary
    public JedisConnectionFactory  jedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
        //配置redis链接信息
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration(redisDataSourceProperties.getHost(),redisDataSourceProperties.getPort());
        //设置密码
        redisStandaloneConfiguration.setPassword(RedisPassword.of(redisDataSourceProperties.getPassword()));
        //设置默认database
        redisStandaloneConfiguration.setDatabase(redisDataSourceProperties.getDatabase());
        JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfigurationBuilder = JedisClientConfiguration.builder();
        //设置超时时间
        jedisClientConfigurationBuilder.connectTimeout(Duration.ofSeconds(redisDataSourceProperties.getTimeout()));
        //设置链接池
        jedisClientConfigurationBuilder.usePooling().poolConfig(jedisPoolConfig);
        //创建工厂对象
        JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration,jedisClientConfigurationBuilder.build());
        return factory;
    }
    /**
     * 配置redis序列化方式
     * @param factory
     * @return
     */
    @Bean("redisTemplate")
    public RedisTemplate redisTemplate(RedisConnectionFactory factory){
        RedisTemplate redisTemplate = new RedisTemplate<>();
        //设置链接工厂
        redisTemplate.setConnectionFactory(factory);
        RedisSerializer keySerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会抛出异常
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(keySerializer);
        // hashkey采用String的序列化方式
        redisTemplate.setHashKeySerializer(keySerializer);

        // value序列化方式采用jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    @Primary //@Primary： 当出现相同名字的bean是，优先使用使用了 @Primary 注解的bean
    public RedisService redisUtil(@Qualifier("redisTemplate") RedisTemplate redisTemplate){
        RedisService redisUtil = new RedisService(redisTemplate);
        return redisUtil;
    }


    /**
     * 设置SpringCacheManager ，通过在类名启用@EnableCaching 来开启springcache
     * 配置完此bean之后，可以通过@Cacheable/@CachePut/@CacheEvict 来进行操作缓存
     * @Cacheable   ： 根据key从缓存中取值，存在则获取后直接返回，不执行业务方法；不存在则执行业务方法，讲业务方法返回的数据存入缓存
     * @CachePut    ： 根据key从缓存中取值，无论数据是否存在，业务方法都会执行，并且业务方法返回的数据存入内存
     * @CacheEvict  ： 执行业务方法之后，删除缓存中的数据
     * @param factory
     * @return
     */
    @Bean("cacheManager")
    @Primary
    public CacheManager cacheManager(RedisConnectionFactory factory){
        RedisCacheConfiguration redisAutoConfiguration = RedisCacheConfiguration
                .defaultCacheConfig() //获取redisCache实例
                .entryTtl(Duration.ofHours(1L)) //设置缓存过期时间
                .computePrefixWith(cacheName -> "cache".concat(":").concat(cacheName).concat(":")) //给key值拼接前缀 cache: 类似于传入 key 最后存的时候 是 cache:key
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) //设置key序列化方式
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())) //设置value序列化方式
                ;

        RedisCacheManager redisCacheManager = RedisCacheManager
                .builder(factory) //获取redisCacheManager
                .cacheDefaults(redisAutoConfiguration)
                .build();
        return redisCacheManager;
    }

}

 
  
        4.4 springboot装配文件 spring.factories
 
  
 
   
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
lilock.cn.common.redis.properties.RedisDataSourceProperties,\
lilock.cn.common.redis.config.RedisConfig
 
  
 
  
 到目前位置，redis 自动装配已经完成，接下来就是测试了
 
  
5.新建lilock-server-user模块 
 
  
引入 lilock-common-spring-redis-starter
 
  


    
        lilock-modules
        lilock.cn
        1.0-SNAPSHOT
        
    
    4.0.0
    1.0-SNAPSHOT
    lilock-service-user
    jar
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-test
        
       
            lilock.cn
            lilock-common-spring-redis-starter
            ${project.version}
        
        
            io.springfox
            springfox-swagger2
        
        
            io.springfox
            springfox-swagger-ui
        
    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

 
  
        5.1 application.yml配置redis参数
 
  
 
   
lilock:
  redis:
    host: 127.0.0.1
    port: 6379
    max-idle: 10 #设置最大空闲连接数，默认为8
    max-wait-millis: -1 #获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
    max-total: 20 #设置最大连接数,默认18个
    min-evictable-idle-time-millis: 18000 #设置连接最小的逐出间隔时间，默认1800000毫秒
    num-tests-per-eviction-run: 5 #每次逐出检查时,逐出连接的个数 默认为3
    time-between-eviction-runs-millis: -1 #设置连接对象有效性扫描间隔,设置为-1,则不运行逐出线程
    timeout: 10 #链接超时时间默认2秒
    test-on-borrow: true # 在连接对象返回时，是否测试对象的有效性,默认false
    test-while-idle: true # 在连接池空闲时是否测试连接对象的有效性,默认false
    database: 0
    password:
server:
  port: 8988
spring:
  profiles:
    active: dev

 
  
 
  
         5.2 新建测试类
 
  
package lilock.cn.user.controller;

import io.swagger.annotations.Api;
import lilock.cn.common.redis.template.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(path = "/user")
@Api(value = "系统用户",tags = {"系统用户"})
@Slf4j
public class UserController {

    @Autowired
    private RedisService redisService;

    @GetMapping("/test")
    public String getUser(){
        log.info("{}",redisService);
        redisService.setExpire("zs","张三",1000);
        String value = redisService.getStrValue("zs");
        return value;
    }

}

 
  
        5.3 测试结果
 
  
1.springcloud微服务架构搭建 之 《springboot自动装配Redis》_第1张图片
 
  
搞定！
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 华为云分布式缓存服务DCS 8月新特性发布
                        华为云PaaS服务小智
华为云分布式缓存
                        
    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    
                    
    • 
                    
  • 非对称加密算法————RSA理论及详情
                        hu19930613

                        
    转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
    
                    
    • 
                    
  • Redis Key的过期策略
                        ArchManual
分布式架构分布式Java后端微服务架构redis
                        
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
    
                    
    • 
                    
  • 加载资源时报错-ERR_CONNECTION_RESET，需要多次请求才能拿到资源的有效解决方案
                        Mebius1916
前端开发前端javascriptreact.js前端框架typescriptvue.js
                        
    初次加载资源时无法正常加载，需要多次刷新、请求才能拿到资源的有效解决方案前言在使用cloudinary进行图片上传并获取图片链接作为用户头像时发现，图片链接网址初次加载会报错：ERR_CONNECTION_RESET必须刷新几次才能获取到，原因可能是cloudinary没有国内的节点，而我用的是在新加坡的节点，所以会导致初次加载的时候被重定向。而这个错误会直接导致用户头像无法加载，因为在img中此
    
                    
    • 
                    
  • Redis:缓存击穿
                        我的程序快快跑啊
缓存redisjava
                        
    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    
                    
    • 
                    
  • Redis 有哪些危险命令？如何防范？
                        花小疯
redis缓存数据库危险命令大数据
                        
    Redis有哪些危险命令？Redis的危险命令主要有以下几个：1.keys客户端可查询出所有存在的键。2.flushdb删除Redis中当前所在数据库中的所有记录，并且此命令从不会执行失败。3.flushall删除Redis中所有数据库中的所有记录，不止是当前所在数据库，并且此命令从不会执行失败。4.config客户端可修改Redis配置。怎么禁用和重命名危险命令？看下redis.conf默认配置
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • 如何重启Linux服务器？
                        老男孩IT教育
gitlinux运维
                        
    在Linux操作系统中，提供了多种方法用于重启服务器，那么Linux服务器如何重启?以下列举了常用的几种方法，希望对大家有所帮助，快来看看吧。重启Linux服务器有以下几种方法：1、使用命令行使用reboot命令reboot使用shutdown命令shutdown-rnow2、使用systemctl使用以下命令：systemctlreboot3、使用web界面大多数现代Linux发行版本都提供一个
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • 小米嵌入式面试题目RTOS面试题目 嵌入式面试题目
                        好家伙VCC
面试杂谈杂谈面试职场和发展
                        
    第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                                
  • HttpClient 4.3与4.3版本以下版本比较
                                    spjich
javahttpclient
                                    
    网上利用java发送http请求的代码很多，一搜一大把，有的利用的是java.net.*下的HttpURLConnection，有的用httpclient，而且发送的代码也分门别类。今天我们主要来说的是利用httpclient发送请求。 
httpclient又可分为 
 
 httpclient3.x 
 httpclient4.x到httpclient4.3以下 
 httpclient4.3
    
                                
    • 
                                
  • Essential Studio Enterprise Edition 2015 v1新功能体验
                                    Axiba
.net
                                    
    概述：Essential Studio已全线升级至2015 v1版本了！新版本为JavaScript和ASP.NET MVC添加了新的文件资源管理器控件，还有其他一些控件功能升级，精彩不容错过，让我们一起来看看吧！ 
syncfusion公司是世界领先的Windows开发组件提供商，该公司正式对外发布Essential Studio Enterprise Edition 2015 v1版本。新版本
    
                                
    • 
                                
  • [宇宙与天文]微波背景辐射值与地球温度
                                    comsci
背景
                                    
     
 
 
        宇宙这个庞大,无边无际的空间是否存在某种确定的,变化的温度呢? 
 
     如果宇宙微波背景辐射值是表示宇宙空间温度的参数之一,那么测量这些数值,并观测周围的恒星能量输出值,我们是否获得地球的长期气候变化的情况呢? 
 
 
  &nbs
    
                                
    • 
                                
  • lvs-server
                                    男人50
server
                                    
    #!/bin/bash 
# 
# LVS script for VS/DR 
# 
#./etc/rc.d/init.d/functions 
# 
VIP=10.10.6.252 
RIP1=10.10.6.101 
RIP2=10.10.6.13 
PORT=80 
case $1 in 
start) 
 
  /sbin/ifconfig eth2:0 $VIP broadca
    
                                
    • 
                                
  • java的WebCollector爬虫框架
                                    oloz
爬虫
                                    
    WebCollector主页： 
https://github.com/CrawlScript/WebCollector 
 
下载：webcollector-版本号-bin.zip将解压后文件夹中的所有jar包添加到工程既可。 
 
接下来看demo 
package org.spider.myspider;

import cn.edu.hfut.dmic.webcollector.cra
    
                                
    • 
                                
  • jQuery append 与 after 的区别
                                    小猪猪08

                                    
    1、after函数 
定义和用法： 
after() 方法在被选元素后插入指定的内容。 
语法： 
$(selector).after(content) 
实例： 
<html> 
<head> 
<script type="text/javascript" src="/jquery/jquery.js"></scr
    
                                
    • 
                                
  • mysql知识充电
                                    香水浓
mysql
                                    
    索引  
索引是在存储引擎中实现的，因此每种存储引擎的索引都不一定完全相同，并且每种存储引擎也不一定支持所有索引类型。 
 
根据存储引擎定义每个表的最大索引数和最大索引长度。所有存储引擎支持每个表至少16个索引，总索引长度至少为256字节。 
 
大多数存储引擎有更高的限制。MYSQL中索引的存储类型有两种：BTREE和HASH，具体和表的存储引擎相关； 
 
MYISAM和InnoDB存储引擎
    
                                
    • 
                                
  • 我的架构经验系列文章索引
                                    agevs
架构
                                    
    下面是一些个人架构上的总结，本来想只在公司内部进行共享的，因此内容写的口语化一点，也没什么图示，所有内容没有查任何资料是脑子里面的东西吐出来的因此可能会不准确不全，希望抛砖引玉，大家互相讨论。 
要注意，我这些文章是一个总体的架构经验不针对具体的语言和平台，因此也不一定是适用所有的语言和平台的。 
（内容是前几天写的，现附上索引） 
  
 
 前端架构 http://www.
    
                                
    • 
                                
  • Android so lib库远程http下载和动态注册
                                    aijuans
andorid
                                    
    一、背景 
  
   在开发Android应用程序的实现，有时候需要引入第三方so lib库，但第三方so库比较大，例如开源第三方播放组件ffmpeg库, 如果直接打包的apk包里面, 整个应用程序会大很多.经过查阅资料和实验，发现通过远程下载so文件，然后再动态注册so文件时可行的。主要需要解决下载so文件存放位置以及文件读写权限问题。 
  
二、主要
    
                                
    • 
                                
  • linux中svn配置出错 conf/svnserve.conf:12: Option expected 解决方法
                                    baalwolf
option
                                    
    在客户端访问subversion版本库时出现这个错误： 
svnserve.conf:12: Option expected 
为什么会出现这个错误呢，就是因为subversion读取配置文件svnserve.conf时，无法识别有前置空格的配置文件，如### This file controls the configuration of the svnserve daemon, if you##
    
                                
    • 
                                
  • MongoDB的连接池和连接管理
                                    BigCat2013
mongodb
                                    
    在关系型数据库中，我们总是需要关闭使用的数据库连接，不然大量的创建连接会导致资源的浪费甚至于数据库宕机。这篇文章主要想解释一下mongoDB的连接池以及连接管理机制，如果正对此有疑惑的朋友可以看一下。 
通常我们习惯于new 一个connection并且通常在finally语句中调用connection的close()方法将其关闭。正巧，mongoDB中当我们new一个Mongo的时候，会发现它也
    
                                
    • 
                                
  • AngularJS使用Socket.IO
                                    bijian1013
JavaScriptAngularJSSocket.IO
                                    
            目前，web应用普遍被要求是实时web应用，即服务端的数据更新之后，应用能立即更新。以前使用的技术（例如polling）存在一些局限性，而且有时我们需要在客户端打开一个socket，然后进行通信。 
        Socket.IO(http://socket.io/)是一个非常优秀的库，它可以帮你实
    
                                
    • 
                                
  • [Maven学习笔记四]Maven依赖特性
                                    bit1129
maven
                                    
    三个模块 
为了说明问题，以用户登陆小web应用为例。通常一个web应用分为三个模块，模型和数据持久化层user-core, 业务逻辑层user-service以及web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和user-service 
  
依赖作用范围 
 Maven的dependency定义
    
                                
    • 
                                
  • 【Akka一】Akka入门
                                    bit1129
akka
                                    
    什么是Akka 
Message-Driven Runtime is the Foundation to Reactive Applications 
In Akka, your business logic is driven through message-based communication patterns that are independent of physical locatio
    
                                
    • 
                                
  • zabbix_api之perl语言写法
                                    ronin47
zabbix_api之perl
                                    
    zabbix_api网上比较多的写法是python或curl。上次我用java－－http://bossr.iteye.com/blog/2195679，这次用perl。for example:   #!/usr/bin/perl 
 
 use 5.010 ; 
 use strict ; 
 use warnings ; 
 use JSON :: RPC :: Client ; 
 use 
    
                                
    • 
                                
  • 比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！
                                    brotherlamp
linux运维工程师linux运维工程师教程linux运维工程师视频linux运维工程师资料linux运维工程师自学
                                    
    比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！ 
  
----------------------------------------------------- 
兄弟连Linux运维工程师课堂实录-计算机基础-1-课程体系介绍1 
链接：http://pan.baidu.com/s/1i3GQtGL 密码：bl65 
  
兄弟连Lin
    
                                
    • 
                                
  • bitmap求哈密顿距离-给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(
                                    bylijinnan
java
                                    
    
import java.util.Random;

/**
 * 题目：
 * 给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(y1,y2,y3,y4,y5)，
 * 使得他们的哈密顿距离（d=|x1-y1| + |x2-y2| + |x3-y3| + |x4-y4| + |x5-y5|）最大
    
                                
    • 
                                
  • map的三种遍历方法
                                    chicony
map
                                    
      
package com.test;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TestMap {
    public static v
    
                                
    • 
                                
  • Linux安装mysql的一些坑
                                    chenchao051
linux
                                    
    1、mysql不建议在root用户下运行 
  
2、出现服务启动不了，111错误，注意要用chown来赋予权限， 我在root用户下装的mysql，我就把usr/share/mysql/mysql.server复制到/etc/init.d/mysqld, (同时把my-huge.cnf复制/etc/my.cnf)  
chown -R cc /etc/init.d/mysql
    
                                
    • 
                                
  • Sublime Text 3 配置
                                    daizj
配置Sublime Text
                                    
    Sublime Text 3 配置解释(默认){// 设置主题文件“color_scheme”: “Packages/Color Scheme – Default/Monokai.tmTheme”,// 设置字体和大小“font_face”: “Consolas”,“font_size”: 12,// 字体选项：no_bold不显示粗体字，no_italic不显示斜体字，no_antialias和
    
                                
    • 
                                
  • MySQL server has gone away 问题的解决方法
                                    dcj3sjt126com
SQL Server
                                    
    MySQL server has gone away 问题解决方法，需要的朋友可以参考下。 
应用程序（比如PHP）长时间的执行批量的MYSQL语句。执行一个SQL，但SQL语句过大或者语句中含有BLOB或者longblob字段。比如，图片数据的处理。都容易引起MySQL server has gone away。 今天遇到类似的情景，MySQL只是冷冷的说：MySQL server h
    
                                
    • 
                                
  • javascript/dom:固定居中效果
                                    dcj3sjt126com
JavaScript
                                    
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml&
    
                                
    • 
                                
  • 使用 Spring 2.5 注释驱动的 IoC 功能
                                    e200702084
springbean配置管理IOCOffice
                                    
    使用 Spring 2.5 注释驱动的 IoC 功能 
 developerWorks 
 
 
文档选项 
 将打印机的版面设置成横向打印模式 
 
打印本页 
 将此页作为电子邮件发送 
 
将此页作为电子邮件发送 
 
级别： 初级 
 
陈 雄华 ([email protected]), 技术总监, 宝宝淘网络科技有限公司 
 
2008 年 2 月 28 日 
 
 &nb
    
                                
    • 
                                
  • MongoDB常用操作命令
                                    geeksun
mongodb
                                    
    1.   基本操作 
db.AddUser(username,password)               添加用户 
db.auth(usrename,password)      设置数据库连接验证 
db.cloneDataBase(fromhost)     
    
                                
    • 
                                
  • php写守护进程（Daemon）
                                    hongtoushizi
PHP
                                    
    转载自： http://blog.csdn.net/tengzhaorong/article/details/9764655 
  
守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。 
  
1、基本概念 
  &nbs
    
                                
    • 
                                
  • spring整合mybatis,关于注入Dao对象出错问题
                                    jonsvien
DAOspringbeanmybatisprototype
                                    
    今天在公司测试功能时发现一问题： 
先进行代码说明： 
1，controller配置了Scope="prototype"（表明每一次请求都是原子型） 
   @resource/@autowired service对象都可以（两种注解都可以）。 
2，service 配置了Scope="prototype"（表明每一次请求都是原子型） 

    
                                
    • 
                                
  • 对象关系行为模式之标识映射
                                    home198979
PHP架构企业应用对象关系标识映射
                                    
    HELLO!架构 
  
一、概念 
identity Map:通过在映射中保存每个已经加载的对象，确保每个对象只加载一次，当要访问对象的时候，通过映射来查找它们。其实在数据源架构模式之数据映射器代码中有提及到标识映射，Mapper类的getFromMap方法就是实现标识映射的实现。 
  
  
二、为什么要使用标识映射？ 
在数据源架构模式之数据映射器中 
//c
    
                                
    • 
                                
  • Linux下hosts文件详解
                                    pda158
linux
                                    
    　1、主机名：   　　无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。   　　公网：IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。   　　局域网：每台机器都有一个主机名，用于主机与主机之间的便于区分，就可以为每台机器设置主机
    
                                
    • 
                                
  • nginx配置文件粗解
                                    spjich
javanginx
                                    
    #运行用户#user  nobody;#启动进程,通常设置成和cpu的数量相等worker_processes  2;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  inf
    
                                
    • 
                                
  • 数学函数
                                    w54653520
java
                                    
    public  
class  
S {       
     
// 传入两个整数，进行比较，返回两个数中的最大值的方法。   
     
public  
int  
get( 
int  
num1, 
int  
nu
    
                                
    •