左弦月
左弦月

Redis相关操作工具类

 基础版：

import java.util.concurrent.TimeUnit;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;


/**
 * Redis帮助类
 * 
 * @author aaa
 */
public class RedisCacheUtils implements BeanFactoryAware {

    private static BeanFactory beanFactory = null;

    /**
     * 设置缓存
     * 
     * @param key
     * @param object
     * @param expireTime 秒
     */
    @SuppressWarnings("unchecked")
    public static void set(String key, Object object, long expireTime) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (!StringUtils.isEmpty(key) && redisTemplate != null && redisTemplate.opsForValue() != null) {
            if (expireTime > 0) {
                redisTemplate.opsForValue().set(key, object, expireTime, TimeUnit.SECONDS);
            }
            else {
                redisTemplate.opsForValue().set(key, object, 86400L, TimeUnit.SECONDS);
            }
        }

    }

    /**
     * 删除缓存
     * 
     * @param key
     */
    @SuppressWarnings("unchecked")
    public static void del(String key) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (!StringUtils.isEmpty(key) && redisTemplate != null) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 获取缓存
     * 
     * @param key
     * @return
     */
    @SuppressWarnings("unchecked")
    public static  T get(String key, Class clazz) {
        Object obj = null;
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate != null && redisTemplate.opsForValue() != null) {
            obj = redisTemplate.opsForValue().get(key);
        }
        if (null != obj) {
            return clazz.cast(obj);
        }
        else {
            return null;
        }
    }

    /**
     * 设置Hash类型缓存
     * 
     * @author aaa
     * @param key
     * @param hashKey
     * @param object
     * @param expireTime
     */
    public static void setH(String key, Object hashKey, Object object, long expireTime) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (!StringUtils.isEmpty(key) && redisTemplate != null && redisTemplate.opsForHash() != null) {
            redisTemplate.opsForHash().put(key, hashKey, object);
            if (expireTime > 0) {
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            }
            else {
                redisTemplate.expire(key, CacheConstant.REDIS_DEAULT_EXPIRE, TimeUnit.SECONDS);
            }
        }
    }

    /**
     * 设置Hash类型
     * 
     * @param key
     * @param hashKey
     * @param object
     */
    public static void setH(String key, Object hashKey, Object object) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (!StringUtils.isEmpty(key) && redisTemplate != null && redisTemplate.opsForHash() != null) {
            redisTemplate.opsForHash().put(key, hashKey, object);
        }
    }

    /**
     * 获取Hash类型缓存
     * 
     * @author aaa
     * @param key
     * @param hashKey
     * @param clazz
     */
    @SuppressWarnings("unchecked")
    public static  T getH(String key, Object hashKey, Class clazz) {
        Object obj = null;
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate != null && redisTemplate.opsForHash() != null) {
            obj = redisTemplate.opsForHash().get(key, hashKey);
        }
        if (null != obj) {
            return clazz.cast(obj);
        }
        else {
            return null;
        }
    }

    /**
     * 获取Hash类型缓存
     * 
     * @author aaa
     * @param key
     * @param hashKey
     */
    @SuppressWarnings("unchecked")
    public static void delH(String key, Object hashKey) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (!StringUtils.isEmpty(key) && null != hashKey && redisTemplate != null
                && redisTemplate.opsForHash() != null) {
            redisTemplate.opsForHash().delete(key, hashKey);
        }

    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        RedisCacheUtils.beanFactory = beanFactory;
    }

    public static Object getBean(String bean) {
        if (beanFactory != null) {
            return beanFactory.getBean(bean);
        }
        return null;
    }

    public static RedisTemplate getRedisTemplate() {
        return (RedisTemplate) getBean("redisTemplate");
    }
}

 优化版：

import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.lang.NonNull;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * 

 * redis缓存工具类
 * 

 *
 * @author aaa
 */
@Slf4j
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class RedisCacheExtUtils implements BeanFactoryAware {

    private static BeanFactory beanFactory = null;
    private static final RedisCacheExtUtils INSTANCE = new RedisCacheExtUtils();

    public static RedisCacheExtUtils getInstance() {
        return INSTANCE;
    }

    public static boolean hasKey(String key) {
        return hasKey(key, e -> {
            throw new RuntimeException(e);
        });
    }

    public static boolean hasKey(String key, Predicate predicate) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate == null) {
            return false;
        }
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            return predicate.test(e);
        }
    }

    public static boolean hasKey(String key, String hashKey) {
        return hasKey(key, hashKey, e -> {
            throw new RuntimeException(e);
        });
    }

    public static boolean hasKey(String key, String hashKey, Predicate predicate) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate == null) {
            return false;
        }
        try {
            return redisTemplate.opsForHash().hasKey(key, hashKey);
        } catch (Exception e) {
            return predicate.test(e);
        }
    }

    /**
     * 设置缓存
     *
     * @param key key
     * @param object object
     * @param expireTime 秒
     */
    public static void set(String key, Object object, long expireTime) {
        set(key, object, expireTime, e -> {
            throw new RuntimeException(e);
        });
    }

    public static void set(String key, Object object, long expireTime, Function function) {
        try {
            RedisCacheUtils.set(key, object, expireTime);
        } catch (Exception e) {
            function.apply(e);
        }
    }

    /**
     * 删除缓存
     *
     * @param key key
     */
    public static void del(String key) {
        del(key, e -> {
            throw new RuntimeException(e);
        });
    }

    public static void del(String key, Function function) {
        try {
            RedisCacheUtils.del(key);
        } catch (Exception e) {
            function.apply(e);
        }
    }

    /**
     * 获取缓存
     *
     * @param key key
     * @return 值
     */
    public static  T get(String key) {
        return get(key, e -> {
            throw new RuntimeException(e);
        });
    }

    public static  T get(String key, Function function) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate == null) {
            return function.apply(null);
        }
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            return function.apply(e);
        }
    }

    /**
     * 设置Hash类型缓存
     *
     * @author aaa
     * @param key key
     * @param hashKey hashKey
     * @param object object
     * @param expireTime expireTime
     */
    public static  void setH(String key, String hashKey, T object, long expireTime) {
        setH(key, hashKey, object, expireTime, e -> {
            throw new RuntimeException(e);
        });
    }

    public static  void setH(String key, String hashKey, T object, long expireTime, Function function) {
        try {
            long actualExpireTime = expireTime > 0 ? expireTime : CacheConstant.REDIS_DEAULT_EXPIRE;
            RedisTemplate redisTemplate = getRedisTemplate();
            if (redisTemplate != null) {
                HashOperations hashOperations = redisTemplate.opsForHash();
                redisTemplate.execute(new SessionCallback() {
                    @Override
                    public Object execute(@NonNull RedisOperations operations) throws DataAccessException {
                        operations.multi();
                        hashOperations.put(key, hashKey, object);
                        redisTemplate.expire(key, actualExpireTime, TimeUnit.SECONDS);
                        return operations.exec();
                    }
                });
            }
        } catch (Exception e) {
            function.apply(e);
        }
    }

    /**
     * 设置Hash类型
     *
     * @param key key
     * @param hashKey hashKey
     * @param object object
     */
    public static void setH(String key, String hashKey, Object object) {
        setH(key, hashKey, object, e -> {
            throw new RuntimeException(e);
        });
    }

    public static void setH(String key, String hashKey, Object object, Function function) {
        try {
            RedisCacheUtils.setH(key, hashKey, object);
        } catch (Exception e) {
            function.apply(e);
        }
    }

    public static  void setH(String key, Map map) {
        setH(key, map, e -> {
            throw new RuntimeException(e);
        });
    }

    public static  void setH(String key, Map map, Function function) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            if (redisTemplate != null) {
                redisTemplate.opsForHash().putAll(key, map);
            }
        } catch (Exception e) {
            function.apply(e);
        }
    }

    public static  void setH(String key, Map map, long expireTime) {
        setH(key, map, expireTime, e -> {
            throw new RuntimeException(e);
        });
    }

    public static  void setH(String key, Map map, long expireTime, Function function) {
        try {
            RedisTemplate redisTemplate = getRedisTemplate();
            if (redisTemplate != null) {
                HashOperations hashOperations = redisTemplate.opsForHash();
                redisTemplate.execute(new SessionCallback() {
                    @Override
                    public Object execute(@NonNull RedisOperations operations) throws DataAccessException {
                        operations.multi();
                        hashOperations.putAll(key, map);
                        redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                        return operations.exec();
                    }
                });
            }
        } catch (Exception e) {
            function.apply(e);
        }
    }

    /**
     * 获取Hash类型缓存
     *
     * @author aaa
     * @param key key
     * @param hashKey hashKey
     */
    public static  T getH(String key, String hashKey) {
        return getH(key, hashKey, e -> {
            throw new RuntimeException(e);
        });
    }

    public static  T getH(String key, String hashKey, Function function) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate == null) {
            return function.apply(null);
        }
        try {
            HashOperations hashOperations = redisTemplate.opsForHash();
            return hashOperations.get(key, hashKey);
        } catch (Exception e) {
            log.error("RedisCacheExtUtils.getH error!", e);
            return function.apply(e);
        }
    }

    public static  List getH(String key, Collection hashKeys) {
        return getH(key, hashKeys, e -> {
            throw new RuntimeException(e);
        });
    }

    public static  List getH(String key, Collection hashKeys, Function> function) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate == null) {
            return function.apply(null);
        }
        try {
            HashOperations hashOperations = redisTemplate.opsForHash();
            return hashOperations.multiGet(key, Arrays.asList(hashKeys.toArray()));
        } catch (Exception e) {
            return function.apply(e);
        }
    }

    /**
     * 获取Hash类型缓存
     *
     * @author aaa
     * @param key key
     * @param hashKey hashKey
     */
    public static void delH(String key, String hashKey) {
        delH(key, hashKey, e -> {
            throw new RuntimeException(e);
        });
    }

    public static void delH(String key, String hashKey, Function function) {
        try {
            RedisCacheUtils.delH(key, hashKey);
        } catch (Exception e) {
            function.apply(e);
        }
    }

    public static  T script(String script, List keys, Object... args) {
        return script(e -> {
            throw new RuntimeException(e);
        }, script, keys, args);
    }

    @SuppressWarnings("unchecked")
    public static  T script(Function function, String script, List keys, Object... args) {
        RedisTemplate redisTemplate = getRedisTemplate();
        if (redisTemplate == null) {
            return function.apply(null);
        }
        try {
            return (T) redisTemplate.execute(new DefaultRedisScript<>(script, Object.class), keys, args);
        } catch (Exception e) {
            return function.apply(e);
        }
    }

    public static void expire(String key, long expireTime, TimeUnit timeUnit) {
        expire(key, expireTime, timeUnit, e -> {
            throw new RuntimeException(e);
        });
    }

    public static void expire(String key, long expireTime, TimeUnit timeUnit, Function function) {
        RedisTemplate redisTemplate = RedisCacheUtils.getRedisTemplate();
        if (redisTemplate != null) {
            try {
                redisTemplate.expire(key, expireTime, timeUnit);
            } catch (Exception e) {
                function.apply(e);
            }
        }
    }

    public static boolean setNX(String key, String value, long expireTime, TimeUnit timeUnit) {
        return setNX(key, value, expireTime, timeUnit, e -> {
            throw new RuntimeException(e);
        });
    }

    public static boolean setNX(String key, String value, long expireTime, TimeUnit timeUnit, Predicate predicate) {
        RedisTemplate redisTemplate = RedisCacheUtils.getRedisTemplate();
        if (redisTemplate == null) {
            return false;
        }
        try {
            Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, expireTime, timeUnit);
            return result != null && result;
        } catch (Exception e) {
            return predicate.test(e);
        }
    }

    @Override
    public void setBeanFactory(@NonNull BeanFactory beanFactory) throws BeansException {
        RedisCacheExtUtils.beanFactory = beanFactory;
    }

    public static Object getBean(String bean) {
        if (beanFactory != null) {
            return beanFactory.getBean(bean);
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    public static  RedisTemplate getRedisTemplate() {
        return (RedisTemplate) getBean("redisTemplate");
    }
}

优化的点：提供了一个redis连不上，或者执行报错的时候的Function接口给调用方，用来处理缓存异常的时候，提供容错解决办法，比如查数据库、返回默认值等


Redis相关操作工具类_第1张图片


Redis分布式工具类：


package com.zte.crm.iepms.common.util;

import com.google.common.collect.Maps;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Nonnull;
import javax.annotation.PostConstruct;
import java.security.SecureRandom;
import java.text.MessageFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.function.Predicate;

import static java.util.concurrent.TimeUnit.MILLISECONDS;

/**
 * redis 分布式锁工具类
 *
 * @author aaa
 * @since 2018/11/2 11:20
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class RedisLockUtils implements EnvironmentAware {

    private static final String PARAM_SERVICE_NAME = "spring.application.name";
    private static final RedisLockUtils INSTANCE = new RedisLockUtils();

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisLockUtils.class);
    private static final ThreadLocal> TARGET_LOCKED = new ThreadLocal<>();
    private static final Map DAEMON_LOCK_MAP = new ConcurrentHashMap<>();

    private static final String UNLOCK_LUA_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    private static final Long RELEASE_SUCCESS = 1L;
    /**
     * 锁超时时间，防止线程在入锁以后，无限的执行等待
     */
    private static final long EXPIRE_MSECS = 60_000;
    /**
     * 锁等待时间，防止线程饥饿
     */
    private static final long TIMEOUT_MSECS = 50_000;
	/**
	 * 默认的锁请求间隔时间
	 */
    private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 50;

	/** 分布式锁key serviceName:lock:lockTarget */
	private static String LOCK_KEY = "{0}:lock:%s";
	private static Environment environment;

    @PostConstruct
	public void daemonThreadStart() {
		String redisLockPrefix = environment.getProperty("redis.lock.prefix");
		if (!StringUtils.hasText(redisLockPrefix)) {
			redisLockPrefix = environment.getProperty(PARAM_SERVICE_NAME);
		}
		LOCK_KEY = MessageFormat.format(LOCK_KEY, redisLockPrefix);
		// 此处开启一个锁守护线程
		new ScheduledThreadPoolExecutor(1, CommonUtils.getThreadFactory("lock-daemon-thread", true))
				.scheduleWithFixedDelay(() -> {
			Iterator> iterator = DAEMON_LOCK_MAP.entrySet().iterator();
			// 间隔10s检查一下锁持有者与锁标记缓存中的持有者标记是否一致
			while (iterator.hasNext()) {
				Map.Entry entry = iterator.next();
				String lockKey = entry.getKey();
				if (entry.getValue().equals(RedisCacheExtUtils.get(lockKey))) {
					RedisCacheExtUtils.expire(lockKey, EXPIRE_MSECS, MILLISECONDS);
				} else {
					iterator.remove();
				}
			}
		}, 5_000, 10_000, MILLISECONDS);
	}

	public static RedisLockUtils getInstance() {
		return INSTANCE;
	}

	/**
	 * 同一线程加锁解锁
	 *
	 * @param lockTarget 锁目标
	 */
    public static void lock(String lockTarget) {
        lock(lockTarget, e -> {
        	throw new RuntimeException(e);
		});
    }

	/**
	 * 同一线程加锁解锁
	 *
	 * @param lockTarget 锁目标
	 * @param predicate 异常时处理方式
	 */
	public static void lock(String lockTarget, Predicate predicate) {
		doLock(lockTarget, s -> tryLock(s, predicate));
	}

	/**
	 * 可以支持不同线程加锁解锁场景
	 *
	 * @param lockTarget 锁目标
	 * @param requestId 钥匙
	 */
	public static void lock(String lockTarget, String requestId) {
		lock(lockTarget, requestId, e -> {
			throw new RuntimeException(e);
		});

	}

	/**
	 * 可以支持不同线程加锁解锁场景
	 *
	 * @param lockTarget 锁目标
	 * @param requestId 钥匙
	 * @param predicate 异常时处理方式
	 */
	public static void lock(String lockTarget, String requestId, Predicate predicate) {
		doLock(lockTarget, s -> tryLock(s, requestId, predicate));
	}

	/**
	 * 尝试获取redis锁
	 * @param lockTarget lockTarget
	 * @return 获取redis锁是否成功
	 */
	public static boolean tryLock(String lockTarget) {
		return tryLock(lockTarget, e -> {
			throw new RuntimeException(e);
		});
	}

	public static boolean tryLock(String lockTarget, Predicate predicate) {
		return tryLock(lockTarget, EXPIRE_MSECS, predicate);
	}

	/**
	 * 尝试获取redis锁, 并设置锁超时时间
	 *
	 * @param lockTarget lockTarget
	 * @param timeout timeout 毫秒
	 * @return 获取redis锁是否成功
	 */
    public static boolean tryLock(String lockTarget, long timeout) {
		return tryLock(lockTarget, timeout, e -> {
			throw new RuntimeException(e);
		});
	}

	public static boolean tryLock(String lockTarget, long timeout, Predicate predicate) {
		String requestId = getLockTargetRequestId(lockTarget);
		try {
			if (tryLock(lockTarget, requestId, timeout, predicate)) {
				return true;
			}
			clearLockedTarget(lockTarget);
			return false;
		} catch (Exception e) {
			clearLockedTarget(lockTarget);
			throw e;
		}
	}

	public static boolean tryLock(String lockTarget, String requestId) {
    	return tryLock(lockTarget, requestId, e -> {
    		throw new RuntimeException(e);
		});
	}

	public static boolean tryLock(String lockTarget, String requestId, Predicate predicate) {
		return tryLock(lockTarget, requestId, EXPIRE_MSECS, predicate);
	}

	public static boolean tryLock(String lockTarget, String requestId, long timeout) {
		return tryLock(lockTarget, requestId, timeout, e -> {
			throw new RuntimeException(e);
		});
	}

	public static boolean tryLock(String lockTarget, String requestId, long timeout, Predicate predicate) {
		String lockKey = String.format(LOCK_KEY, lockTarget);
		try {
			if (doTryLock(lockKey, requestId, timeout)) {
				// 获取锁成功
				// 将锁标记缓存到锁标记缓存
				DAEMON_LOCK_MAP.put(lockKey, requestId);
				return true;
			}
			return false;
		} catch (Exception e) {
			LOGGER.error(e.getMessage(), e);
			return predicate.test(e);
		}
	}

	/**
	 * 同一线程解锁
	 *
	 * @param lockTarget lockTarget
	 */
	public static void unLock(String lockTarget) {
		unLock(lockTarget, e -> {
			throw new RuntimeException(e);
		});
	}

	/**
	 * 同一线程解锁
	 *
	 * @param lockTarget lockTarget
	 * @param predicate 异常处理方式
	 */
	public static void unLock(String lockTarget, Predicate predicate) {
		try {
			unLock(lockTarget, getLockTargetRequestId(lockTarget), predicate);
		} finally {
			clearLockedTarget(lockTarget);
		}
	}

	/**
	 * 支持部同线程解锁
	 *
	 * @param lockTarget lockTarget
	 */
	public static void unLock(String lockTarget, String requestId) {
		unLock(lockTarget, requestId, e -> {
			throw new RuntimeException(e);
		});
	}

	public static void unLock(String lockTarget, String requestId, Predicate predicate) {
		String lockKey = String.format(LOCK_KEY, lockTarget);
		List keys = Collections.singletonList(lockKey);
		try {
			Long result = RedisCacheExtUtils.script(UNLOCK_LUA_SCRIPT, keys, requestId);
			if (!RELEASE_SUCCESS.equals(result)) {
				LOGGER.warn("【{}】释放【{}】锁失败", requestId, lockKey);
			} else if (LOGGER.isDebugEnabled()) {
				LOGGER.info("【{}】释放【{}】锁成功", requestId, lockKey);
			}
		} catch (Exception e) {
			LOGGER.error(e.getMessage(), e);
			predicate.test(e);
		} finally {
			// 删除本地守护线程缓存锁标记 requestId与DAEMON_LOCK_MAP.get(lockKey)相等时清除
			DAEMON_LOCK_MAP.computeIfPresent(lockKey, (key, old) -> Objects.equals(requestId, old) ? null : old);
		}
	}

	/**
	 * 执行加锁
	 *
	 * @param lockTarget 锁目标
	 * @param tryLockPredicate 尝试加锁方法
	 */
	private static void doLock(String lockTarget, Predicate tryLockPredicate) {
		int timeCost = 0;
		SecureRandom random = new SecureRandom();
		try {
			do {
				if (tryLockPredicate.test(lockTarget)) {
					return;
				}
				/*
				 * 获取锁失败 自旋等待
				 * 延迟50-100毫秒随机事件, 这里使用随机时间可能会好一点,可以防止饥饿进程的出现,即,当同时到达多个进程,
				 * 只会有一个进程获得锁,其他的都用同样的频率进行尝试,后面有来了一些进行,也以同样的频率申请锁,这将可能导致前面来的锁得不到满足.
				 * 使用随机的等待时间可以一定程度上保证公平性
				 */
				int acquiryResolutionMillis = random.nextInt(51) + DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
				Thread.sleep(acquiryResolutionMillis);
				timeCost += acquiryResolutionMillis;
			} while (timeCost < TIMEOUT_MSECS);
		} catch (InterruptedException e) {
			LOGGER.error("=========线程中止失败======");
			Thread.currentThread().interrupt();
		}
		// 获取锁失败并超过获取锁的等待时间 给出服务器繁忙 稍后重试的业务异常
		throw new BusinessException(RetCode.BUSINESSERROR_CODE, SERVER_BUSY_ERROR_MSGID);
	}

	/**
	 * 当前线程获取锁目标钥匙
	 *
	 * @param lockTarget 锁目标
	 * @return 钥匙
	 */
	private static String getLockTargetRequestId(String lockTarget) {
		Map targetLockedMap = TARGET_LOCKED.get();
		if (CollectionUtils.isEmpty(targetLockedMap)) {
			targetLockedMap = Maps.newHashMap();
		}
		String requestId = targetLockedMap.get(lockTarget);
		if (!StringUtils.hasText(requestId)) {
			requestId = StringHelper.getGUID();
			targetLockedMap.put(lockTarget, requestId);
			TARGET_LOCKED.set(targetLockedMap);
		}
		return requestId;
	}

	private static void clearLockedTarget(String lockTarget) {
		Map targetLockedMap = TARGET_LOCKED.get();
		targetLockedMap.remove(lockTarget);
		if (CollectionUtils.isEmpty(targetLockedMap)) {
			TARGET_LOCKED.remove();
		}
	}

	/**
	 * 尝试获取redis锁
	 * @param lockKey lockKey
	 * @param requestId requestId
	 * @return 获取redis锁是否成功
	 */
	private static boolean doTryLock(String lockKey, String requestId, long timeout) {
		return RedisCacheExtUtils.setNX(lockKey, requestId, timeout, MILLISECONDS);
	}

	@Override
	public void setEnvironment(@Nonnull Environment environment) {
		RedisLockUtils.environment = environment;
	}
}



 依赖的StringHelper.getGUID()方法如下：


public class StringHelper {


    public StringHelper() {
    }

    public static String getGUID() {
        UUID uuid = UUID.randomUUID();
        return uuid.toString();
    }
}


private static String LOCK_KEY = "{0}:lock:%s";


MessageFormat.format(LOCK_KEY, redisLockPrefix); // 替换{0}


String lockKey = String.format(LOCK_KEY, lockTarget); // 替换%s

























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






    

  • java多态介绍及与C++多态性的比较
xiaoweids
编程语言javajavaservletjvm

    一、通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。1.如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。2.如果a是接口A的一个引用，那么,a必须指向实现了接
    

    • 

  • js数组方法map和filter
人间废料记
javascriptjavascript前端

    目录.map()方法概念语法注意使用场景.filter()方法概念语法注意使用场景.map()和.filter()的区别和联系.map()方法概念.map()函数是JavaScript数组结构中很实用的一个方法之一。可以将map()方法视为经过一个循环并在回调函数中编写语句（格式化、数据处理）以构造一个新数组。用来创建新数组、修改其内容并保持原始数组不变的通用方法。当出现需要修改现有数组的内容并将
    

    • 

  • javascript - 模拟 for-in 循环
廖马儿

    获取："key,value"在for循环中。varlist={'aaa':'111','bbb':'222','ccc':'333'};我知道可以用forin语句获取键值对的值如下for(varkeyinlist){key;//输出aaabbbccclist[key]//输出为111222333}
    

    • 

  • IDEA测试类启动报 “java: 常量字符串过长” 解决办法
无休居士
Java工程常见异常javaintellij-ideaide

    目录标题问题描述问题分析解决办法其他办法问题描述问题分析字符串长度过长，导致idea默认使用的javac编译器编译不了。查询资料发现，原因是javac在编译期间，常量字符串最大长度为65534。解决办法Javac编译器改为Eclipse编译器。File->Settings->Build,Execution,Deployment->Compiler->JavaCompiler其他办法如果不是新建pr
    

    • 

  • 前端发布 CDN缓存
跳动的世界线
前端缓存CDN

    公司给服务器加了CDN，导致有时前端代码上传打包后，正式环境页面效果却不更新。每次都需要去找运维刷CDN…让我彻底记住了CDN缓存CDN（ContentDeliveryNetwork，内容分发网络）是一种广泛使用的互联网技术，旨在提高用户访问网站的速度和可靠性。CDN的核心思想是将网站的内容缓存到全球分布的边缘节点上，让用户能够从最近的节点获取数据，从而减少延迟和带宽消耗。CDN缓存机制的基本原理
    

    • 

  • java基础-线程间通信方式
问道飞鱼
Java开发技术java开发语言

    文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
    

    • 

  • Java 后端程序员必须要懂的几种框架分享
Java烟雨
javamvc开发语言

    MVC框架MVC模式是软件工程中的一种软件架构模式，可以把软件系统分为三个基本部分：模型（Model），编写程序应有的功能（实现算法等等）、进行数据管理和数据库设计，。视图（View），界面设计人员进行图形界面设计。控制器（Controller），负责转发请求，对请求进行处理。比较知名的MVC框架有SpringMVC，是一种基于请求驱动类型的轻量级Web框架，目的是帮助我们后端程序员简化开发。我个
    

    • 

  • Java 中自定义线程池
胡英俊俊俊
#JUCjava开发语言

    Java中自定义线程池的方式在Java开发中，线程池是非常常用的工具，它能够帮助我们更好地管理多线程任务，提升并发性能并避免过度创建线程导致的系统资源消耗。在Java中，线程池主要由ThreadPoolExecutor提供，该类支持自定义线程池的核心参数，如线程数、任务队列以及拒绝策略等。在这篇文章中，我们将讨论如何通过ThreadPoolExecutor来实现自定义线程池，以及常用的配置和使用方
    

    • 

  • 浅拷贝与深拷贝
・T・T・
面试前端javascriptlodash

    浅拷贝浅拷贝创建了一个新的对象或数组，但仅复制了顶层的属性或元素。对于嵌套的对象或数组，复制的仍然是引用。Object.assignObject.assign是JavaScript中用于复制对象属性的一个方法。它可以用来实现浅拷贝consttarget={};constsource={a:1,b:{c:2}};//浅拷贝source到targetObject.assign(target,sourc
    

    • 

  • 刷刷前端手写题
・T・T・
面试前端javascript面试

    闭包用途闭包闭包让你可以在一个内层函数中访问到其外层函数的作用域防抖描述前面所有触发都被取消，最后一次执行，在规定时间之后才会触发，也就是说如果连续快速的触发，用户操作频繁，但只会执行一次。常用场景：输入框输入代码实现1、lodash的debounce函数2、当用户点击按钮时，debounce包装的getBtnValue函数会延迟3000毫秒执行。如果在这3000毫秒内用户再次点击按钮，那么之前的
    

    • 

  • java unix网络编程_《UNIX网络编程 卷2：进程间通信(第2版)》PDF 下载
weixin_39688019
javaunix网络编程

    图书目录：第一部分简介第1章简介1.1概述1.2进程、线程与信息共享1.3IPC对象的持续性1.4名字空间1.5fork、exec和exit对IPC对象的影响1.6出错处理：包裹函数1.7Unix标准1.8书中IPC例子索引表1.9小结习题第2章PosixIPC2.1概述2.2IPC名字2.3创建与打开IPC通道2.4IPC权限2.5小结习题第3章SystemVIPC3.1概述3.2key_t键和
    

    • 

  • Java Spring Boot 全面教程
极客代码
玩转Javajavaspringboot开发语言后端

    一、SpringBoot简介与环境搭建1.1SpringBoot简介SpringBoot是一种基于Java的开源框架，由PivotalSoftware开发，旨在简化新Spring应用程序的初始化、配置和部署过程。它遵循约定优于配置的原则，通过内嵌的Tomcat、Jetty或Undertow等容器，使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。SpringBoot包含了
    

    • 

  • Linux+Docker：3分钟实现MinIO在线部署与Java集成
码龄23年
linuxdockerjava

    Linux下使用Docker安装MinIO1.拉取MinIO镜像dockerpullminio/minio2.创建挂载目录mkdir-p/opt/minio/datamkdir-p/optl/minio/config3.检查端口占用sudolsof-i:9000...4.启动MinIO容器dockerrun--nameminio\#容器名称-p9010:9000\#映射主机端口9010到容器端口9
    

    • 

  • SpringBoot项目
俺叫啥好嘞
spring系列springspringboot

    SpringBoot项目大概分为四层：（1）DAO层：包括XxxMapper.java(数据库访问接口类)，XxxMapper.xml(数据库链接实现)；（这个命名，有人喜欢用Dao命名，有人喜欢用Mapper，看个人习惯了吧）（2）Bean层：也叫model层，模型层，entity层，实体层，就是数据库表的映射实体类，存放POJO对象；（3）Service层：也叫服务层，业务层，包括XxxSer
    

    • 

  • TypeScript 快速入门
echozzi
1024程序员节

    一、TypeScript是什么TypeScript是一种由微软开发的自由和开源的编程语言。于2012年推出。TypeScript是JavaScript的一个超集。为JavaScript添加了类型系统。TypeScript与JavaScript的区别TypeScriptJavaScriptJavaScript的超集用于解决大型项目的代码复杂性一种脚本语言，用于创建动态网页可以在编译期间发现并纠正错误
    

    • 

  • Java-后端程序员个人知识总结
金肴羽
java开发语言

    文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
    

    • 

  • 用前端的语言写后端——Node.js之Express
tabzzz
前端前端node.jsexpress

    ExpressExpress是一种流行的模型视图控制器(MVC)Node.js框架，具有快速、极简和灵活的优点，为Web和移动应用程序开发提供了强大的功能集合。最受欢迎的Node.js框架！文章目录Express安装ExpressHelloWorld路由中间件全局中间件应用中间件开放跨域请求几种常用的Express内置中间件函数1.JSON格式数据中间件函数2.静态文件中间件函数3.路由中间件函数
    

    • 

  • JAVA之接口
java萌新小白

    接口接口的概述电脑上面的主板有很多接口，比如内存条的接口，有了这个接口，可以插入多个内存条，主板和内存条可能不是同一家生产厂商，但是两种物体却能结合到一起，正是因为这个接口的存在。只要厂家遵循这个接口，主板和内存条就可以随意更换，提高了可插拔性，接口其实也是体现着一种规范。在java语言里面使用interface来声明一个接口，接口其实是一个特殊的抽象类，在接口里面的方法全部都是抽象的。关于接口，
    

    • 

  • Spring6学习笔记4：事务
·云扬·
SSMJava#Spring学习笔记spring

    1JdbcTemplate1.1简介Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作准备工作①搭建子模块搭建子模块：spring-jdbc-tx②加入依赖org.springframeworkspring-jdbc6.0.2mysqlmysql-connector-java8.0.30com.alibabadruid1.2.15③创建jdbc.propertie
    

    • 

  • Java程序的分层设计
天天进步2015
架构设计java开发语言

    Java程序的分层设计通常遵循分层架构（LayeredArchitecture）的原则，将应用程序分为多个相互独立但有依赖关系的层。这样设计有助于降低耦合度，提高可维护性和可扩展性。典型的Java分层设计包括以下几层：1.表示层（PresentationLayer/ViewLayer）功能：用户界面层，负责与用户交互。将用户输入的信息传递给业务层，同时将业务层返回的结果展示给用户。一般使用JSP、
    

    • 

  • java中的ide、sdk是什么,javaee\javase\javame区别
极客Thomas
idejavaeclipse

    ide：integrateddevelopmentenvironment集成开发环境简单的来说就是提供编译代码等一系列功能的开发环境比如：eclipsesdk：servicedevelopmentpack服务开发包简单来说就是一些封装的功能代码，做成了一个包，给我们可以直接调用比如jdk1.8jdkjavase（JavaPlatform，StandardEdition）标准版本，在电脑上运行jav
    

    • 

  • java 基础
i0208
java开发语言

    基础数据类型，方法，类，异常处理：Java零基础入门学习（小白也能看懂！）_java零基础自学-CSDN博客List在Java中，List接口是集合框架中非常重要的一个接口，它提供了存储和操作有序集合的方法。List是一个接口，因此不能直接实例化，但可以通过其实现类（如ArrayList,LinkedList,Vector等）来使用。List接口的主要实现类ArrayList:动态数组实现，适用于
    

    • 

  • 前端技能树，面试复习第 29 天—— 简述 Babel 的原理 | Webpack 构建流程 | Webpack 热更新原理 | Git 常用命令
编程轨迹_
前端面试复习笔记前端面试面经前端工程化WebpackBabel前端面试大厂面试题

    31b3479814f74acbb70b9f63f2e80012.gif"width=“100%”>⭐️本文首发自前端修罗场(点击加入社区，参与学习打卡，获取奖励)，是一个由资深开发者独立运行的专业技术社区，我专注Web技术、答疑解惑、面试辅导以及职业发展。。1.Babel的原理是什么?babel的转译过程也分为三个阶段，这三步具体是：解析、转换、生成解析Parse:将代码解析⽣成抽象语法树（AS
    

    • 

  • PTA:7-32 最小公倍数（递归）
萠哥啥都行
java开发语言

    本题目要求读入2个整数a和b，然后输出它们的最小公倍数。输入格式:输入在一行中给出2个正整数，以空格分隔。输出格式:输出最小公倍数。输入样例:在这里给出一组输入。例如：614输出样例:在这里给出相应的输出。例如：42importjava.util.Scanner;publicclassMain{publicstaticintgcd(inta,intb){//辗转相除求最大公约数if(b==0){r
    

    • 

  • 前端开发深入了解webpack
史努比的大头
前端

    什么是webpackWebpack是一个现代JavaScript应用程序的模块打包工具。它主要用于将各种资源（如JavaScript、CSS、图片等）打包成一个或多个文件，以优化Web应用的加载性能。Webpack的核心功能包括：模块化：支持将代码拆分为模块，便于管理和重用。打包：将多个模块和资源打包成一个或多个文件，减少HTTP请求。加载器（Loaders）：处理不同类型的文件（如转换ES6到E
    

    • 

  • 【Webpack】了解Webpack
Sam9029
Webpackwebpack前端node.js

    Sam9029的CSDN博客主页:Sam9029的博客_CSDN博客-前端领域博主‍若此文你认为写的不错，不要吝啬你的赞扬，求收藏，求评论，求一个大大的赞！*文章若有错误或某个内容有更优的解决方案，还望指正！*Webpack了解webpack指南https://webpack.docschina.org/guides/webpack文档https://webpack.docschina.org/前
    

    • 

  • Reactive 编程-Vert.x
Flying_Fish_Xuan
python开发语言

    Reactive编程与Vert.x：高效异步Java微服务框架一、什么是Reactive编程？Reactive编程是一种异步编程范式，专注于数据流和事件的传播处理。与传统的阻塞式编程不同，Reactive编程能够更好地处理高并发和异步操作，特别适合实时系统、流处理以及需要快速响应的场景。Reactive编程的核心原则包括：响应性（Responsive）：系统能够快速响应用户请求，并保持低延迟。弹性
    

    • 

  • Cocos2d、Cocos2dx、Cocos Creator、Cocos Studio的区别
Thomas游戏圈

    一、Cocos2d和Cocos2dx的区别【开发语言】：Cocos2d是Object-C写的，Cocos2dx是C++写的，支持使用C++、Lua或Java进行开发。【运行平台】：Cocos2d只能在IOS下运行，Cocos2dx是跨平台的，适配iOS、Android、HTML5、Windows和Mac系统，功能侧重于原生移动平台。点击链接加入群聊【Unity/Cocos交流群】【国籍】：Coco
    

    • 

  • Hadoop windows intelij 跑 MR WordCount
piziyang12138

    一、软件环境我使用的软件版本如下:IntellijIdea2017.1Maven3.3.9Hadoop分布式环境二、创建maven工程打开Idea,file->new->Project,左侧面板选择maven工程。(如果只跑MapReduce创建java工程即可，不用勾选Creatfromarchetype，如果想创建web工程或者使用骨架可以勾选)image.png设置GroupId和Artif
    

    • 

  • Scala学习之旅－对Option友好的flatMap
喝冰咖啡
scala学习

    聊点什么OptionflatMapvs.OptionOption的作用在Java/Scala中,Optional/Option(本文还是以scala代码为例)是用来表示某个对象存在或者不存在，也就是说,Option是某个类型T的Wrapper,如果T!=null,Option(T).isDefined==true如果T==null,Option(T).isEmpty==true有了Option这层
    

    • 

  • Nginx负载均衡
510888780
nginx应用服务器

    Nginx负载均衡一些基础知识:
nginx 的 upstream目前支持 4 种方式的分配
1)、轮询（默认）
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。
2)、weight
      指定轮询几率，weight和访问比率成正比
    

    • 

  • RedHat 6.4 安装 rabbitmq
bylijinnan
erlangrabbitmqredhat

    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功
机器版本：
[root@redhat1 rabbitmq]# lsb_release
LSB Version: :base-4.0-amd64:base-4.0-noarch:core
    

    • 

  • FilenameUtils工具类
eksliang
FilenameUtilscommon-io

    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    

    • 

  • xml文件解析SAX
不懂事的小屁孩
xml

    xml文件解析:xml文件解析有四种方式，
1.DOM生成和解析XML文档(SAX是基于事件流的解析)
2.SAX生成和解析XML文档(基于XML文档树结构的解析)
3.DOM4J生成和解析XML文档
4.JDOM生成和解析XML
本文章用第一种方法进行解析，使用android常用的DefaultHandler
import org.xml.sax.Attributes;

    

    • 

  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
酷的飞上天空
mysql

    使用python脚本作为命令脚本，linux的定时任务来每天定时执行
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar
#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    

    • 

  • 如何搭建数据湖架构？听听专家的意见
蓝儿唯美
架构

    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    

    • 

  • spring学习——控制反转与依赖注入
a-john
spring

           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。
 

    

    • 

  • 用spool+unixshell生成文本文件的方法
aijuans
xshell

    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:
　　set pages 50000;
　　set lines 200;
　　set trims on;
　　set heading off;
　　spool /oracle_backup/log/test/dept.lst;
　　select deptno||','||dname||','||loc 
    

    • 

  • 1、基础--名词解析(OOA/OOD/OOP)
asia007
学习基础知识

    OOA:Object-Oriented Analysis（面向对象分析方法）
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    

    • 

  • 浅谈java转成json编码格式技术
百合不是茶
json编码java转成json编码

    json编码;是一个轻量级的数据存储和传输的语言
  
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了
 
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非
 
常适合于服务器与 JavaScript 之间的数据的交
    

    • 

  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
bijian1013
javaweb.xmlSSIspring配置

    指定Spring配置文件位置
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
/WEB-INF/
    

    • 

  • Installing SonarQube（Fail to download libraries from server）
sunjing
InstallSonar

    1.  Download and unzip the SonarQube distribution
2.  Starting the Web Server
The default port is "9000" and the context path is "/". These values can be changed in &l
    

    • 

  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
bit1129
mongodb

    一、创建复本集
 
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令：
 
mongod --port 27017 --dbpath data1 --replSet rs0
mongod --port 27018 --dbpath data2 --replSet rs0
mongod --port 27019 -
    

    • 

  • Anychart图表系列二之执行Flash和HTML5渲染
白糖_
Flash

    今天介绍Anychart的Flash和HTML5渲染功能
 
HTML5
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    

    • 

  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
bozch
laravel

    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误：
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    

    • 

  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
bylijinnan
编程之美

    
import java.util.Arrays;
import java.util.Random;
public class Nim {
/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    

    • 

  • lunce创建索引及简单查询
chengxuyuancsdn
查询创建索引lunce

    import java.io.File;
import java.io.IOException;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    

    • 

  • [IT与投资]坚持独立自主的研究核心技术
comsci
it

    
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段.....
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    

    • 

  • flashback transaction闪回事务查询
daizj
oraclesql闪回事务

      
闪回事务查询有别于闪回查询的特点有以下3个：
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    

    • 

  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
游其是你
FilenameFilter

    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
    

    • 

  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
dcj3sjt126com
c

    # include <stdio.h>
int f(void) //括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
return 10; //向主调函数返回10
}
void g(void) //函数名前面的void表示该函数没有返回值
{
//return 10; //error 与第8行行首的void相矛盾
}
in
    

    • 

  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
dcj3sjt126com
centos

    今天在测试环境使用yum安装，遇到一个问题：
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again
 
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。
&n
    

    • 

  • 单例模式
shuizhaosi888
单例模式

    单例模式      懒汉式
public class RunMain {
/**
* 私有构造
*/
private RunMain() {
}
/**
* 内部类，用于占位，只有
*/
private static class SingletonRunMain {
priv
    

    • 

  • Spring Security（09）——Filter
234390216
Spring Security

    Filter
目录
1.1     Filter顺序
1.2     添加Filter到FilterChain
1.3     DelegatingFilterProxy
1.4     FilterChainProxy
1.5
    

    • 

  • 公司项目NODEJS实践0.1
逐行分析JS源代码
mongodbnginxubuntunodejs

     
一、前言
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。
        网上有很多nod
    

    • 

  • java.lang.Math
liuhaibo_ljf
javaMathlang

    System.out.println(Math.PI);
System.out.println(Math.abs(1.2));
System.out.println(Math.abs(1.2));
System.out.println(Math.abs(1));
System.out.println(Math.abs(111111111));
System.out.println(Mat
    

    • 

  • linux下时间同步
nonobaba
ntp

    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    

    • 

  • ZooKeeper3.4.6的集群部署
roadrunners
zookeeper集群部署

    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。
 
1、准备工作
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。
 
数据存储目录
    

    • 

  • Java高效读取大文件
tomcat_oracle
java

    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法： 　　Files.readLines(new File(path), Charsets.UTF_8); 　　FileUtils.readLines(new File(path)); 　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    

    • 

  • 微信支付api返回的xml转换为Map的方法
xu3508620
xmlmap微信api

    举例如下：
<xml>
   <return_code><![CDATA[SUCCESS]]></return_code>
   <return_msg><![CDATA[OK]]></return_msg>
   <appid><
    

    •