weixin_33853827

RedisHelper帮助类

using Newtonsoft.Json;
using RedLockNet.SERedis;
using RedLockNet.SERedis.Configuration;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace 秒杀系统
{
    public class RedisHelper
    {
        private static readonly string RedisHost = "127.0.0.1:6379";
        private static readonly string RedisHost1 = "127.0.0.2:6379";
        private static readonly string RedisPwd = "sa123456";

        private static readonly int RedisDbIndex = 0;
        private static readonly object LockObject = new object();

        private static ConnectionMultiplexer _connection;

        public static ConnectionMultiplexer Connection
        {
            get
            {
                if (_connection == null)
                {
                    lock (LockObject)
                    {
                        if (_connection == null || !_connection.IsConnected)
                        {
                            var config = new ConfigurationOptions
                            {
                                AbortOnConnectFail = false,
                                ConnectRetry = 10,
                                ConnectTimeout = 5000,
                                SyncTimeout = 5000,
                                EndPoints = { { RedisHost } },
                                AllowAdmin = true,
                                KeepAlive = 180,
                                Password = RedisPwd
                            };
                            _connection = ConnectionMultiplexer.Connect(config);
                            //注册如下事件
                            _connection.ConnectionFailed += MuxerConnectionFailed;
                            _connection.ErrorMessage += MuxerErrorMessage;
                            _connection.InternalError += MuxerInternalError;
                        }
                    }
                }
                return _connection;
            }
        }

        public static RedLockFactory redLockFactory;

        public static RedLockFactory RedlockFactory
        {
            get
            {
                if (redLockFactory != null) return redLockFactory;
                var multiplexers = new List()
                {
                    Connection
                };
                var redlockFactory = RedLockFactory.Create(multiplexers);
                return redlockFactory;
            }
        }

        /// 
        /// 获取redis的DB
        /// 
        /// 
        private static IDatabase GetDatabase()
        {
            if (Connection == null || !Connection.IsConnected)
            {
                throw new Exception("redis连接有误");
            }
            return Connection.GetDatabase(RedisDbIndex);
        }

        #region 记录redis的连接日志

        /// 
        /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
        /// 
        /// 
        /// 
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
        }

        /// 
        /// redis类库错误
        /// 
        /// 
        /// 
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
        }

        /// 
        /// 发生错误时
        /// 
        /// 
        /// 
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
        }

        #endregion 记录redis的连接日志

        #region String

        #region 同步方法

        /// 
        /// 保存单个key value
        /// 
        /// Redis Key
        /// 保存的值
        /// 过期时间
        /// 
        public static bool StringSet(string key, string value, int secondTimeout)
        {
            return Do(db => db.StringSet(key, value, TimeSpan.FromSeconds(secondTimeout)));
        }

        /// 
        /// 保存多个key value
        /// 
        /// 键值对
        /// 
        public static bool StringSet(List> keyValues)
        {
            List> newkeyValues =
                keyValues.Select(p => new KeyValuePair(p.Key, p.Value)).ToList();
            return Do(db => db.StringSet(newkeyValues.ToArray()));
        }

        /// 
        /// 保存一个对象
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool StringSet(string key, T obj, int secondTimeout)
        {
            var json = ConvertJson(obj);
            return Do(db => db.StringSet(key, json, TimeSpan.FromSeconds(secondTimeout)));
        }

        /// 
        /// 获取单个key的值
        /// 
        /// Redis Key
        /// 
        public static string StringGet(string key)
        {
            return Do(db => db.StringGet(key));
        }

        /// 
        /// 获取一个key的对象
        /// 
        /// 
        /// 
        /// 
        public static T StringGet(string key)
        {
            return Do(db => ConvertObj(db.StringGet(key)));
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static long StringIncrement(string key, long val = 1)
        {
            return Do(db => db.StringIncrement(key, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static long StringDecrement(string key, long val = 1)
        {
            return Do(db => db.StringDecrement(key, val));
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static double StringIncrement(string key, double val = 1)
        {
            return Do(db => db.StringIncrement(key, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static double StringDecrement(string key, double val = 1)
        {
            return Do(db => db.StringDecrement(key, val));
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 保存单个key value
        /// 
        /// Redis Key
        /// 保存的值
        /// 过期时间
        /// 
        public static async Task<bool> StringSetAsync(string key, string value, int secondTimeout)
        {
            return await Do(db => db.StringSetAsync(key, value, TimeSpan.FromSeconds(secondTimeout)));
        }

        /// 
        /// 保存多个key value
        /// 
        /// 键值对
        /// 
        public static async Task<bool> StringSetAsync(List> keyValues)
        {
            List> newkeyValues =
                keyValues.Select(p => new KeyValuePair(p.Key, p.Value)).ToList();
            return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
        }

        /// 
        /// 保存一个对象
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> StringSetAsync(string key, T obj, int secondTimeout)
        {
            string json = ConvertJson(obj);
            return await Do(db => db.StringSetAsync(key, json, TimeSpan.FromSeconds(secondTimeout)));
        }

        /// 
        /// 获取单个key的值
        /// 
        /// Redis Key
        /// 
        public static async Task<string> StringGetAsync(string key)
        {
            return await Do(db => db.StringGetAsync(key));
        }

        /// 
        /// 获取一个key的对象
        /// 
        /// 
        /// 
        /// 
        public static async Task StringGetAsync(string key)
        {
            string result = await Do(db => db.StringGetAsync(key));
            return ConvertObj(result);
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static async Task<long> StringIncrementAsync(string key, long val = 1)
        {
            return await Do(db => db.StringIncrementAsync(key, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static async Task<long> StringDecrementAsync(string key, long val = 1)
        {
            return await Do(db => db.StringDecrementAsync(key, val));
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static async Task<double> StringIncrementAsync(string key, double val = 1)
        {
            return await Do(db => db.StringIncrementAsync(key, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static async Task<double> StringDecrementAsync(string key, double val = 1)
        {
            return await Do(db => db.StringDecrementAsync(key, val));
        }

        #endregion 异步方法

        #endregion String

        #region Hash

        #region 同步方法

        /// 
        /// 判断某个数据是否已经被缓存
        /// 
        /// 
        /// 
        /// 
        public static bool HashExists(string key, string dataKey)
        {
            return Do(db => db.HashExists(key, dataKey));
        }

        /// 
        /// 存储数据到hash表
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool HashSet(string key, string dataKey, T t)
        {
            return Do(db =>
            {
                string json = ConvertJson(t);
                return db.HashSet(key, dataKey, json);
            });
        }

        /// 
        /// 移除hash中的某值
        /// 
        /// 
        /// 
        /// 
        public static bool HashDel(string key, string dataKey)
        {
            return Do(db => db.HashDelete(key, dataKey));
        }

        /// 
        /// 移除hash中的多个值
        /// 
        /// 
        /// 
        /// 
        public static long HashDel(string key, List dataKeys)
        {
            return Do(db => db.HashDelete(key, dataKeys.ToArray()));
        }

        /// 
        /// 从hash表获取数据
        /// 
        /// 
        /// 
        /// 
        /// 
        public static T HashGet(string key, string dataKey)
        {
            return Do(db =>
            {
                if (!HashExists(key, dataKey)) return default(T);
                string value = db.HashGet(key, dataKey);
                return ConvertObj(value);
            });
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static double HashIncrement(string key, string dataKey, double val = 1)
        {
            return Do(db => db.HashIncrement(key, dataKey, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static double HashDecrement(string key, string dataKey, double val = 1)
        {
            return Do(db => db.HashDecrement(key, dataKey, val));
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 
        /// 
        /// 
        /// 
        public static List HashKeys(string key)
        {
            return Do(db =>
            {
                RedisValue[] values = db.HashKeys(key);
                return ConvetList(values);
            });
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 
        /// 
        /// 
        public static List HashGetAll(string key)
        {
            var values = Do(db => db.HashGetAll(key));
            return ConvetList(values);
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 判断某个数据是否已经被缓存
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> HashExistsAsync(string key, string dataKey)
        {
            return await Do(db => db.HashExistsAsync(key, dataKey));
        }

        /// 
        /// 存储数据到hash表
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> HashSetAsync(string key, string dataKey, T t)
        {
            return await Do(db =>
            {
                string json = ConvertJson(t);
                return db.HashSetAsync(key, dataKey, json);
            });
        }

        /// 
        /// 移除hash中的某值
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> HashDelAsync(string key, string dataKey)
        {
            return await Do(db => db.HashDeleteAsync(key, dataKey));
        }

        /// 
        /// 移除hash中的多个值
        /// 
        /// 
        /// 
        /// 
        public static async Task<long> HashDelAsync(string key, List dataKeys)
        {
            return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
        }

        /// 
        /// 从hash表获取数据
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task HashGeAsync(string key, string dataKey)
        {
            string value = await Do(db => db.HashGetAsync(key, dataKey));
            return ConvertObj(value);
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static async Task<double> HashIncrementAsync(string key, string dataKey, double val = 1)
        {
            return await Do(db => db.HashIncrementAsync(key, dataKey, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static async Task<long> HashDecrementAsync(string key, string dataKey, long val = 1)
        {
            return await Do(db => db.HashDecrementAsync(key, dataKey, val));
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public static async Task<long> HashIncrementAsync(string key, string dataKey, long val = 1)
        {
            return await Do(db => db.HashIncrementAsync(key, dataKey, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public static async Task<double> HashDecrementAsync(string key, string dataKey, double val = 1)
        {
            return await Do(db => db.HashDecrementAsync(key, dataKey, val));
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 
        /// 
        /// 
        /// 
        public static async Task> HashKeysAsync(string key)
        {
            RedisValue[] values = await Do(db => db.HashKeysAsync(key));
            return ConvetList(values);
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 
        /// 
        /// 
        /// 
        public static async Task> HashGetAllAsync(string key)
        {
            var values = await Do(db => db.HashGetAllAsync(key));
            return ConvetList(values);
        }

        #endregion 异步方法

        #endregion Hash

        #region List

        #region 同步方法

        /// 
        /// 移除指定ListId的内部List的值
        /// 
        /// 
        /// 
        public static void ListRemove(string key, T value)
        {
            Do(db => db.ListRemove(key, ConvertJson(value)));
        }

        /// 
        /// 获取指定key的List
        /// 
        /// 
        /// 
        public static List ListRange(string key)
        {
            return Do(redis =>
            {
                var values = redis.ListRange(key);
                return ConvetList(values);
            });
        }

        /// 
        /// 入队
        /// 
        /// 
        /// 
        public static void ListRightPush(string key, T value)
        {
            Do(db => db.ListRightPush(key, ConvertJson(value)));
        }

        /// 
        /// 出队
        /// 
        /// 
        /// 
        /// 
        public static T ListRightPop(string key)
        {
            return Do(db =>
            {
                var value = db.ListRightPop(key);
                return ConvertObj(value);
            });
        }

        /// 
        /// 入栈
        /// 
        /// 
        /// 
        /// 
        public static void ListLeftPush(string key, T value)
        {
            Do(db => db.ListLeftPush(key, ConvertJson(value)));
        }

        /// 
        /// 出栈
        /// 
        /// 
        /// 
        /// 
        public static T ListLeftPop(string key)
        {
            return Do(db =>
            {
                var value = db.ListLeftPop(key);
                return ConvertObj(value);
            });
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public static long ListLength(string key)
        {
            return Do(redis => redis.ListLength(key));
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 移除指定ListId的内部List的值
        /// 
        /// 
        /// 
        public static async Task<long> ListRemoveAsync(string key, T value)
        {
            return await Do(db => db.ListRemoveAsync(key, ConvertJson(value)));
        }

        /// 
        /// 获取指定key的List
        /// 
        /// 
        /// 
        public static async Task> ListRangeAsync(string key)
        {
            var values = await Do(redis => redis.ListRangeAsync(key));
            return ConvetList(values);
        }

        /// 
        /// 入队
        /// 
        /// 
        /// 
        public static async Task<long> ListRightPushAsync(string key, T value)
        {
            return await Do(db => db.ListRightPushAsync(key, ConvertJson(value)));
        }

        /// 
        /// 出队
        /// 
        /// 
        /// 
        /// 
        public static async Task ListRightPopAsync(string key)
        {
            var value = await Do(db => db.ListRightPopAsync(key));
            return ConvertObj(value);
        }

        /// 
        /// 入栈
        /// 
        /// 
        /// 
        /// 
        public static async Task<long> ListLeftPushAsync(string key, T value)
        {
            return await Do(db => db.ListLeftPushAsync(key, ConvertJson(value)));
        }

        /// 
        /// 出栈
        /// 
        /// 
        /// 
        /// 
        public static async Task ListLeftPopAsync(string key)
        {
            var value = await Do(db => db.ListLeftPopAsync(key));
            return ConvertObj(value);
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public static async Task<long> ListLengthAsync(string key)
        {
            return await Do(redis => redis.ListLengthAsync(key));
        }

        #endregion 异步方法

        #endregion List

        #region SortedSet 有序集合

        #region 同步方法

        /// 
        /// 添加
        /// 
        /// 
        /// 
        /// 
        public static bool SortedSetAdd(string key, T value, double score)
        {
            return Do(redis => redis.SortedSetAdd(key, ConvertJson(value), score));
        }

        /// 
        /// 删除
        /// 
        /// 
        /// 
        public static bool SortedSetRemove(string key, T value)
        {
            return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
        }

        /// 
        /// 获取全部
        /// 
        /// 
        /// 
        public static List SortedSetRangeByRank(string key)
        {
            return Do(redis =>
            {
                var values = redis.SortedSetRangeByRank(key);
                return ConvetList(values);
            });
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public static long SortedSetLength(string key)
        {
            return Do(redis => redis.SortedSetLength(key));
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 添加
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> SortedSetAddAsync(string key, T value, double score)
        {
            return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson(value), score));
        }

        /// 
        /// 删除
        /// 
        /// 
        /// 
        public static async Task<bool> SortedSetRemoveAsync(string key, T value)
        {
            return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
        }

        /// 
        /// 获取全部
        /// 
        /// 
        /// 
        public static async Task> SortedSetRangeByRankAsync(string key)
        {
            var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
            return ConvetList(values);
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public static async Task<long> SortedSetLengthAsync(string key)
        {
            return await Do(redis => redis.SortedSetLengthAsync(key));
        }

        #endregion 异步方法

        #endregion SortedSet 有序集合

        #region key

        /// 
        /// 删除单个key
        /// 
        /// redis key
        /// 是否删除成功
        public static bool KeyDel(string key)
        {
            return Do(db => db.KeyDelete(key));
        }

        /// 
        /// 删除多个key
        /// 
        /// rediskey
        /// 成功删除的个数
        public static long KeyDel(List<string> keys)
        {
            return Do(db => db.KeyDelete(ConvertRedisKeys(keys)));
        }

        /// 
        /// 判断key是否存储
        /// 
        /// redis key
        /// 
        public static bool KeyExists(string key)
        {
            return Do(db => db.KeyExists(key));
        }

        /// 
        /// 设置Key的时间
        /// 
        /// redis key
        /// 
        /// 
        public static bool KeyExpire(string key, int secondTimeout)
        {
            return Do(db => db.KeyExpire(key, TimeSpan.FromSeconds(secondTimeout)));
        }

        #endregion key

        #region 辅助方法

        private static T Do(Func func)
        {
            try
            {
                var database = GetDatabase();
                return func(database);
            }
            catch (Exception ex)
            {
                return default(T);
            }
        }

        private static string ConvertJson(T value)
        {
            string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
            return result;
        }

        private static T ConvertObj(RedisValue value)
        {
            if (value.IsNullOrEmpty)
            {
                return default(T);
            }
            return JsonConvert.DeserializeObject(value.ToString());
        }

        private static List ConvetList(RedisValue[] values)
        {
            List result = new List();
            foreach (var item in values)
            {
                var model = ConvertObj(item);
                result.Add(model);
            }
            return result;
        }

        private static RedisKey[] ConvertRedisKeys(List<string> redisKeys)
        {
            return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
        }

        private static List ConvetList(HashEntry[] values)
        {
            List result = new List();
            foreach (var item in values)
            {
                if (!item.Value.IsNullOrEmpty)
                {
                    var model = ConvertObj(item.Value);
                    result.Add(model);
                }
            }
            return result;
        }

        #endregion 辅助方法

        public static IBatch CreateBatch()
        {
            return GetDatabase().CreateBatch();
        }

        public static ITransaction CreateTransaction()
        {
            return GetDatabase().CreateTransaction();
        }

        //使用Keys *模糊匹配Key
        public static List<string> GetMatchKeys(string key)
        {
            var result = (string[])GetDatabase().ScriptEvaluate(LuaScript.Prepare("return redis.call('KEYS',@keypattern)"), new { keypattern = key });
            return result.ToList();
        }

        //使用SCAN模糊匹配Key
        public static List<string> ScanMatchKeys(string key)
        {
            var result = (string[])GetDatabase().ScriptEvaluate(
                LuaScript.Prepare("local dbsize=redis.call('dbsize') local res=redis.call('scan',0,'match',KEYS[1],'count',dbsize) return res[2]"),
                new RedisKey[] { key });
            return result.ToList();
        }
    }
}

android studio SQLite数据库的简单使用爱掉发的小龙 oracle 数据库 android studio java android sqlite
在AndroidStudio中使用数据库可以有多种方式，常见的几种方式包括使用SQLite数据库和使用SQLite数据库SQLite是一款轻量级的关系型数据库管理系统，在Android中被广泛使用。要在AndroidStudio中使用SQLite数据库，需要先创建一个数据库帮助类，这个类继承自SQLiteOpenHelper类，用于创建和管理数据库。在数据库帮助类中，可以定义表结构和数据库操作方法
python使用 sqlalchemy连接数据库帮助类搬砖的诗人Z python python 数据库
importmysql.connectorclassMySqlHelper(object):"""操作数据库帮助类"""def__init__(self):#self.host="localhost"#self.user="root"#self.password="xinshiyun@123"#self.database="deliverunion_callcenter"self.host="19
C#拼音帮助类 weixin_34189116
如果使用此帮助类需要引用usingMicrosoft.International.Converters.PinYinConverter;usingNPinyin;可以在NuGet里面下载1.编码格式为GB2312//////lou2019年5月27日10:17:48Encoding编码///privatestaticreadonlyEncodingGb2312=Encoding.GetEncodi
C#汉字转拼音帮助类 weixin_30615767
usingSystem;usingSystem.Collections.Generic;usingSystem.Text;usingSystem.Text.RegularExpressions;namespaceCommonClass.Util{//////汉字转拼音类///publicclassPinYin{privatestaticreadonlyint[]PyValue=newint[]{-
一个比较全面的C#公共帮助类编程乐趣开源项目 .netcore github c#
上次跟大家推荐过2个C#开发工具箱：《推荐一个不到2MB的C#开发工具箱，集成了上千个常用操作类》、《推荐一个.Net常用代码集合，助你高效完成业务》。今天再给大家推荐一个，这几个部分代码功能有重合的部分，大家可以根据自己的需求，从中选择自己的需要的。项目简介集合网络上比较常用的C#帮助类、公共类，涉及CSV、数据库、PDF、FTP、IP、时间、字符串、拼音、日历、科学计数、线程、视频、验证码、条
c# 拼音帮助类 vbloveshllm c#开发语言
publicclassPinYinHelper{#region获取汉字对应的拼音//////获取汉字对应的拼音/////////publicstaticModel.PinYinGetPinYin(stringstr){varchs=str.ToCharArray();List>Dic=newList>();//记录每个汉字的全拼foreach(varchinchs){varlist=GetPinY
c# 枚举帮助类 vbloveshllm c#java 开发语言
ublicclassEnumHelper{#region返回枚举对应属性//////返回枚举对应属性//////枚举类///publicstaticListEnumToList(){Listlist=newList();varitems=Enum.GetValues(typeof(T));foreach(variteminitems){Model.EnumTypeentity=newModel.E
C# 校验帮助类-正则表达式 huang714 正则表达式 c#前端
一、简介很多时候我们都需要用到一些验证的方法，有时候需要用正则表达式校验数据时，往往需要到网上找很久，结果找到的还不是很符合自己想要的。所以我把自己整理的校验帮助类分享处理，在这里分享一下，给自己留了个底，也给各位需要的朋友们做个参考回到顶部二、校验类片段2.1邮箱验证#regionIsEmail(是否邮箱)//////是否邮箱//////邮箱地址///是否按严格模式验证///publicstat
c# 正则表达式帮助类 vbloveshllm c#正则表达式 windows
publicclassRegexHelper{//////验证输入字符串是否与模式字符串匹配，匹配返回true//////输入字符串///模式字符串publicstaticboolIsMatch(stringinput,stringpattern){returnIsMatch(input,pattern,RegexOptions.IgnoreCase);}//////验证输入字符串是否与模式字符串
c# 字符串帮助类 vbloveshllm c#开发语言
publicclassStringHelper{#region全角半角互相转换//////转全角的函数(SBCcase)//////任意字符串///全角字符串//////全角空格为12288，半角空格为32///其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248///publicstaticstringToSBC(stringstr){//半角转全角：cha
c# DataTable 帮助类 vbloveshllm c#windows 开发语言
publicclassDataTableHelper{#regionDataTable转IList//////DataTable转IList集合////////////publicstaticIListToList(DataTabledataTable)whereT:class,new(){IListlist=newList();//定义集合if(dataTable!=null){foreach(
c# 日历帮助类 vbloveshllm c#java 前端
publicclassCalendarHelper{#region返回本年有多少天//////返回本年有多少天//////年份///本年的天数publicstaticintGetDaysByYear(intyear){intcnt=0;if(IsRuYear(year)){cnt=366;//闰年多1天即：2月为29天}else{cnt=365;//--非闰年少1天即：2月为28天}returnc
c# List集合操作帮助类 vbloveshllm c#list java
publicclassListHelper{#region赋值转换//////A实体转换成B实体////////////原始数据对象///目标对象///publicstaticKEntityToEntity(Tsource,Ktarget)whereT:class,new()whereK:class{if(source!=null&&target!=null){PropertyInfo[]prop
c# Http Get Post Put Delete 请求帮助类 vbloveshllm c#http java
publicclassHttpHelper{#regionGetPostPutDelete请求//////返回指定Url的页面源码,Get提交//////Url地址///编码格式gb2312utf-8,默认utf-8///publicstaticstringHttpGet(stringurl,stringencoding="utf-8"){returnHttpRequest(url,"","get
c# 缓存帮助类 vbloveshllm c#缓存 java
publicclassCacheHelper{privatestaticDictionarydic=newDictionary();//定义一个静态变量来保存类的实例privatestaticCacheHelpersession;//定义一个标识确保线程同步privatestaticreadonlyobjectlocker=newobject();//////单例//////返回类型为Sessio
c# 命令行帮助类 vbloveshllm c#java 开发语言
publicclassCmdHelper{//////执行Cmd命令/////////publicstaticstringExec(stringcmd){varproc=newProcess();proc.StartInfo.FileName="cmd.exe";proc.StartInfo.UseShellExecute=false;//是否使用操作系统shell启动proc.StartInfo
c# 加密解密帮助类 vbloveshllm c#java 前端
publicclassDEncryptHelper{#regionMd5加密//////获取字符串MD5加密字符串//////原始字符串///MD5加密字符串publicstaticstringGetMd5(stringstr){varpwd=System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str
java 加密解密类_java 加密解密帮助类风不留行 java 加密解密类
一、MD5帮助类/***功能简介：MD5加密工具类*密码等安全信息存入数据库时，转换成MD5加密形式*@author*/publicclassMD5Util{publicstaticStringgetMd5(StringinStr){StringoutStr=null;if(inStr==null){outStr=null;}elseif("".equals(inStr)){outStr="";}
C#写个小工具，把多个word文档进行合并成一个word文档搬砖的诗人Z C#winform c#word 开发语言
先要安装包帮助类WordDocumentMerger，用于处理word合并功能usingSystem;usingSystem.Collections.Generic;usingSystem.Text;usingMicrosoft.Office.Interop.Word;usingSystem.Reflection;usingSystem.IO;usingSystem.Diagnostics;nam
NCalendar日历的封装使用奔跑的佩恩
前言在Android开发过程中，我们经常会遇到需要选择日期的问题。今天基于NCalendar库封装了一个DatePopHelper帮助类，以达到快速实现日期选择的目的。下面就来讲讲DatePopHelper的使用吧。今天涉及知识：NCalendar库依赖NCalendar基本使用的简单介绍DatePopHelper使用前的一些准备DatePopHelper使用介绍DatePopHelper在Act
c#简单模拟商品秒杀深渊！ C#基础
主函数：classProgram{publicstaticListthreads=newList();publicstaticintcount=0;publicstaticListplist=newList();staticvoidMain(string[]args){//数据生成//for(inti=0;ikeyValuePairs=RedisHelper.GetAllEntriesFromHa
Netty入门 - （秒懂）- 图解Netty系列 40岁资深老架构师尼恩 java
Netty入门疯狂创客圈Java分布式聊天室【亿级流量】实战系列之-入门【博客园总入口】文章目录Netty入门前言：建立项目编写一个DiscardHandler处理器编写一个Discard服务器线程组启动帮助类设置Channel通道的选项测试：发送消息到Discard服务器写在最后疯狂创客圈Java死磕系列前言：问题：我们需要高度优化的协议现在我们使用通用应用程序或包进行通信。例如，我们经常使用H
.NETCORE 开发登录接口MFA谷歌多因子身份验证行走的生活 .netcore
1.maf帮助类publicclassGoogleAuthenticator{privatereadonlystaticDateTime_epoch=newDateTime(1970,1,1,0,0,0,DateTimeKind.Utc);privateTimeSpanDefaultClockDriftTolerance{get;set;}publicGoogleAuthenticator(){D
Asp .Net Core 系列：Asp .Net Core 配置 System.Text.Json Code技术分享 .netcore json ui
文章目录简介Asp.NetCore如何配置System.Text.Json所有配置全局配置对比Newtonsoft.Json无实体类型下操作Json自定义转换器处理Dynamic类型封装常用配置封装JsonHelper帮助类简介System.Text.Json命名空间提供用于序列化和反序列化JavaScript对象表示法(JSON)的功能。序列化是将对象状态（即其属性的值）转换为可存储或传输的形式
Docker常用命令你小子在看什么…… Docker docker 容器
目录一、系统级别类命令1.启动docker2.停止Docker3.重启Docker4.查看状态5.设置开机自启6.取消开机自启7.查看占据的空间二、帮助类命令1.查看Docker版本2.查看Docker概要信息3、查看Docker总体帮助文档4、查看docker具体命令帮助文档三、容器管理命令1.列出运行中的容器2.列出本地主机上的镜像3.删除容器4.搜索DockerHub中镜像5.下载Docke
IDEA常用插件（本人常用，不全）北风toto 次要的个人笔记 intellij-idea java ide
文章目录一、图标提示类插件1、Lombok插件（用户配合lombok依赖的工具）2、MybatisX插件3、GitToolBox4、VUE.js5、ESLint二、代码自动生成插件1、EasyCode插件：自动生成代码神器2、GsonFormat三、常用工具类1、IDEEvalReset插件（重置体验时间）2、Translation插件（中英文翻译）3、RedisHelper：Redis助手4、R
C#反射详解 Qayrup c#开发语言
一、反射是什么1、C#编译运行过程高级语言->编译->dll/exe文件->CLR/JIT->机器码2、原理解析metadata：元数据数据清单，记录了dll中包含了哪些东西,是一个描述。IL：中间语言，编译把高级语言编译后得到的C#中最真实的语言状态，面向对象语言。反射：来自于System.Reflection，是一个帮助类库，可以读取dll/exe中metadata，使用metadata创建对
java 解析word模板（2024-01-25）北漂一族1988 java java 开发语言
本文主要功能是解析word模板这是一个word解析类，因为我做的系统用到了而且没有可用的帮助类，只能自己写。之前的实现方式是freemarker模板解析。但是这次要求用poi不在使用freemarker。实现功能比较少，主要是满足开发需求即可，没有实现其它功能。实现功能如下：1、word内文本内容解析2、word内表格内容解析3、word内图片内容解析4、word脚注内容解析功能实现的比较匆忙没有
孩子的好习惯,从哪里来? 耳朵姐姐
孩子的好习惯,从哪里来?怎样才能帮助孩子培养好习惯,提升独立自主的能力。你注意到了吗?在这句话里,我用了两个关键词:一个是“帮助”,另外一个是“培养”。好习惯和独立性不会凭空产生,需要父母的帮助,需要时间来培养。但很多时候,我们立刻马上就希望孩子能形成好习惯,这可有点不切合实际。形成好习惯,不同的孩子所需要的帮助类型不同,而他们所需的时间也不同。如果有的孩子所需要的时间长一点,这并不能说明孩子不好
C# 简答操作共享内存方法小猫会飞 C#共享内存 C#共享内存
C#操作共享内存的一个帮助类，读写和打开classShareMemoryHelper{[DllImport("Kernel32.dll",CharSet=CharSet.Auto)]privatestaticexternIntPtrOpenFileMapping(intdwDesiredAccess,[MarshalAs(UnmanagedType.Bool)]boolbInheritHandle
tomcat基础与部署发布暗黑小菠萝 Tomcat java web
从51cto搬家了，以后会更新在这里方便自己查看。做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。一、Tomcat安装安装方式：①运行.exe安装包 &n
网站架构发展的过程 ayaoxinchao 数据库应用服务器网站架构
1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
[信息与安全]数据库的备份问题 comsci 数据库
如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? &n
使用maven tomcat plugin插件debug关联源代码商人shang maven debug 查看源码 tomcat-plugin
*首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 *配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
大访问量高并发 oloz 大访问量高并发
大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简要列出几点解决方案： 01、优化你的代码和查询语句，合理使用索引 02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 03、采用服务器集群、负载均衡分担大访问量高并发压力 04、数据读写分离 05、合理选用框架，合理架构(推荐分布式架构)。
cache 服务器小猪猪08 cache
Cache 即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。　　1.Cache 是怎么样工作的? 　　Cache 是分配在服务器上
mysql存储过程香水浓 mysql
Description:插入大量测试数据 use xmpl; drop procedure if exists mockup_test_data_sp; create procedure mockup_test_data_sp( in number_of_records int ) begin declare cnt int; declare name varch
CSS的class、id、css文件名的常用命名规则 agevs JavaScript UI 框架 Ajax css
CSS的class、id、css文件名的常用命名规则 (一)常用的CSS命名规则　　头：header 　　内容：content/container 　　尾：footer 　　导航：nav 　　侧栏：sidebar 　　栏目：column 　　页面外围控制整体布局宽度：wrapper 　　左右中：left right
全局数据源 AILIKES java tomcat mysql jdbc JNDI
实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
MYSQL的随机查询的实现方法 baalwolf mysql
MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
JAVA的getBytes()方法 bijian1013 java eclipse unix OS
在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！ String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： byte[] b_gbk = "
AngularJS中操作Cookies bijian1013 JavaScript AngularJS Cookies
如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
[Maven学习笔记五]Maven聚合和继承特性 bit1129 maven
Maven聚合在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块： 1. 模型和数据持久化层user-core, 2. 业务逻辑层user-service以 3. web展现层user-web， user-service依赖于user-core user-web依赖于user-core和use
【JVM七】JVM知识点总结 bit1129 jvm
1. JVM运行模式 1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler
linux下查看nginx、apache、mysql、php的编译参数 ronin47
在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 1、nginx [root@361way ~]# /App/nginx/sbin/nginx -V nginx: nginx version: nginx/
unity中运用Resources.Load的方法？ brotherlamp unity视频 unity资料 unity自学 unity unity教程
问：unity中运用Resources.Load的方法？答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 1、unity实时替换的物体即是依据环境条件
线段树-入门 bylijinnan java 算法线段树
/** * 线段树入门 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i] * * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18 * @author lijinna
全选与反选 chicony 全选
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title>全选与反选</title>
vim一些简单记录 chenchao051 vim
mac在/usr/share/vim/vimrc linux在/etc/vimrc 1、问：后退键不能删除数据，不能往后退怎么办？答：在vimrc中加入set backspace=2 2、问：如何控制tab键的缩进？答：在vimrc中加入set tabstop=4 (任何
Sublime Text 快捷键 daizj 快捷键 sublime
[size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
php 引用(&)详解 dcj3sjt126com PHP
在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址变量的引用 PHP 的引用允许你用两个变量来指向同一个内容复制代码代码如下: <? $a="ABC"; $b =&$a; echo
SVN中trunk,branches,tags用法详解 dcj3sjt126com SVN
Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
对软件设计的思考 e200702084 设计模式数据结构算法 ssh 活动
软件设计的宏观与微观软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
同步、异步、阻塞、非阻塞 geeksun 非阻塞
同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。实现：
Reverse SSH Tunnel 反向打洞實錄 hongtoushizi ssh
實際的操作步驟： # 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port ssh -NfR 12345:localhost:22 [email protected] # 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器 ssh localhost -p 1
Hibernate中的缓存 Josh_Persistence 一级缓存 Hiberante缓存查询缓存二级缓存
Hibernate中的缓存一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
对象关系行为模式之延迟加载 home198979 PHP 架构延迟加载
形象化设计模式实战 HELLO!架构一、概念 Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。二、实现延迟加载实现Lazy Load主要有四种方法：延迟初始化、虚
xml 验证 pengfeicao521 xml xml解析
有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 public static void testPattern() { // 含有非法字符的串 String str = "Jamey친Ñ&#1282
div设置半透明效果 spjich css 半透明
为div设置如下样式： div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;} 说明： 1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
你真的了解单例模式么？ w574240966 java 单例设计模式 jvm
单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。一，单例模式的5中写法。（回字的四种写法，哈哈。） 1，懒汉式（1）线程不安全的懒汉式 public cla

RedisHelper帮助类

你可能感兴趣的:(RedisHelper帮助类)