精华内容
下载资源
问答
  • 2.客服微信(用户客服微信手动下分) 3.自动(需要您有微信企业付款到零钱的公众号) 不需要公众号也能玩,支持个人免签支付接口+企业自动提现,新增个人免签支付接口,用户提现有三种:手动提现,客服,企业...
  • 已破解授权,所有代码无任何加密,目前市值2K左右,分享给码农学习,感谢支持!此源码不提供技术支持, 本源码提供给大家学习研究借鉴美工之用,请勿用于商业和非法...注意在公众号后台设置,安全域名和授权回调域名
  • 前端有很多方法可以将网站设置成完全灰色,可以通过调CSS样式,可以滤镜,可以通过js控制样式等。然而,对应不那么熟悉前端的后台开发或维护人员,只能从网站找些资源,东拼西凑。尝试很多次,最麻烦的是IE浏览器...

    前端有很多方法可以将网站设置成完全灰色,可以通过调CSS样式,可以加滤镜,可以通过js控制样式等。然而,对不那么熟悉前端的后台开发或维护人员,只能从网上找办法,东拼西凑。尝试很多次,最麻烦的是IE浏览器网页死活不变灰色。下面以我解决过的一个生产问题为例,彻底解决了手工替换彩色图标、图片的尴尬且耗时的问题,支持IE浏览器。

    在html中引入css样式(不支持IE显示置灰)

    对于一开始没有考虑到默哀日置灰的网站,只要在每个h5网页代码中引入css样式,或者在已经引入到所有网页的公共css里面修改代码也可以。我是新建了一个css文件turngray.css,代码如下:

    html{
        filter: gray !important;
        filter: progid:DXImageTransform.Microsoft.BasicImage(grayscale=1);
        filter: grayscale(100%);
        -webkit-filter: grayscale(100%);
        -moz-filter: grayscale(100%);
        -ms-filter: grayscale(100%);
        -o-filter: grayscale(100%); 
    }
    

    说明:除了IE浏览器,我试过,这段代码对360安全浏览器、谷歌浏览器、火狐浏览器等大多数浏览器都起作用。按F12,可以看到实际起作用的是 -webkit-filter: grayscale(100%);这行代码。

    接下来是在需要变灰的网页代码文件中引入css

        <link rel="stylesheet" type="text/css" href="../assets/css/turngray.css" />
    

    (相对路径根据实际项目目录来定,此处仅仅举例)

    在html引入js(支持IE)

    主要是解决IE浏览器中页面死活不变灰的情况。我在网上找到grayscale.js。代码如下:

    /*
     * -- grayscale.js --
     * Copyright (C) James Padolsey (http://cn.baiwanzhan.com)
     *
     */
    
    var grayscale = (function(){
        
        var config = {
                colorProps: ['color','backgroundColor','borderBottomColor','borderTopColor','borderLeftColor','borderRightColor','backgroundImage'],
                externalImageHandler : {
                    /* Grayscaling externally hosted images does not work
                       - Use these functions to handle those images as you so desire */
                    /* Out of convenience these functions are also used for browsers
                       like Chrome that do not support CanvasContext.getImageData */
                    init : function(el, src) {
                        if (el.nodeName.toLowerCase() === 'img') {
                            // Is IMG element...
                        } else {
                            // Is background-image element:
                            // Default - remove background images
                            data(el).backgroundImageSRC = src;
                            el.style.backgroundImage = '';
                        }
                    },
                    reset : function(el) {
                        if (el.nodeName.toLowerCase() === 'img') {
                            // Is IMG element...
                        } else {
                            // Is background-image element:
                            el.style.backgroundImage = 'url(' + (data(el).backgroundImageSRC || '') + ')';
                        }
                    }
                }
            },
            log = function(){
                try { window.console.log.apply(console, arguments); }
                catch(e) {};
            },
            isExternal = function(url) {
                // Checks whether URL is external: 'CanvasContext.getImageData'
                // only works if the image is on the current domain.
                return (new RegExp('https?://(?!' + window.location.hostname + ')')).test(url);
            },
            data = (function(){
                
                var cache = [0],
                expando = 'data' + (+new Date());
                
                return function(elem) {
                    var cacheIndex = elem[expando],
                        nextCacheIndex = cache.length;
                    if(!cacheIndex) {
                        cacheIndex = elem[expando] = nextCacheIndex;
                        cache[cacheIndex] = {};
                    }
                    return cache[cacheIndex];
                };
                
            })(),
            desatIMG = function(img, prepare, realEl) {
                
                // realEl is only set when img is temp (for BG images)
                
                var canvas = document.createElement('canvas'),
                    context = canvas.getContext('2d'),
                    height = img.naturalHeight || img.offsetHeight || img.height,
                    width = img.naturalWidth || img.offsetWidth || img.width,
                    imgData;
                    
                canvas.height = height;
                canvas.width = width;
                context.drawImage(img, 0, 0);
                try {
                    imgData = context.getImageData(0, 0, width, height);
                } catch(e) {}
                
                if (prepare) {
                    desatIMG.preparing = true;
                    // Slowly recurse through pixels for prep,
                    // :: only occurs on grayscale.prepare()
                    var y = 0;
                    (function(){
                        
                        if (!desatIMG.preparing) { return; }
                        
                        if (y === height) {
                            // Finished!
                            context.putImageData(imgData, 0, 0, 0, 0, width, height);
                            realEl ? (data(realEl).BGdataURL = canvas.toDataURL())
                                   : (data(img).dataURL = canvas.toDataURL())
                        }
                        
                        for (var x = 0; x < width; x++) {
                            var i = (y * width + x) * 4;
                            // Apply Monoschrome level across all channels:
                            imgData.data[i] = imgData.data[i+1] = imgData.data[i+2] =
                            RGBtoGRAYSCALE(imgData.data[i], imgData.data[i+1], imgData.data[i+2]);
                        }
                        
                        y++;
                        setTimeout(arguments.callee, 0);
                        
                    })();
                    return;
                } else {
                    // If desatIMG was called without 'prepare' flag
                    // then cancel recursion and proceed with force! (below)
                    desatIMG.preparing = false;
                }
                
                for (var y = 0; y < height; y++) {
                    for (var x = 0; x < width; x++) {
                        var i = (y * width + x) * 4;
                        // Apply Monoschrome level across all channels:
                        imgData.data[i] = imgData.data[i+1] = imgData.data[i+2] =
                        RGBtoGRAYSCALE(imgData.data[i], imgData.data[i+1], imgData.data[i+2]);
                    }
                }
                
                context.putImageData(imgData, 0, 0, 0, 0, width, height);
                return canvas;
            
            },
            getStyle = function(el, prop) {
                var style = document.defaultView && document.defaultView.getComputedStyle ? 
                            document.defaultView.getComputedStyle(el, null)[prop]
                            : el.currentStyle[prop];
                // If format is #FFFFFF: (convert to RGB)
                if (style && /^#[A-F0-9]/i.test(style)) {
                        var hex = style.match(/[A-F0-9]{2}/ig);
                        style = 'rgb(' + parseInt(hex[0], 16) + ','
                                       + parseInt(hex[1], 16) + ','
                                       + parseInt(hex[2], 16) + ')';
                }
                return style;
            },
            RGBtoGRAYSCALE = function(r,g,b) {
                // Returns single monochrome figure:
                return parseInt( (0.2125 * r) + (0.7154 * g) + (0.0721 * b), 10 );
            },
            getAllNodes = function(context) {
                var all = Array.prototype.slice.call(context.getElementsByTagName('*'));
                all.unshift(context);
                return all;
            };
            
        var init = function(context) {
            
            // Handle if a DOM collection is passed instead of a single el:
            if (context && context[0] && context.length && context[0].nodeName) {
                // Is a DOM collection:
                var allContexts = Array.prototype.slice.call(context),
                    cIndex = -1, cLen = allContexts.length;
                while (++cIndex<cLen) { init.call(this, allContexts[cIndex]); }
                return;
            }
            
            context = context || document.documentElement;
            
            if (!document.createElement('canvas').getContext) {
                context.style.filter = 'progid:DXImageTransform.Microsoft.BasicImage(grayscale=1)';
                context.style.zoom = 1;
                return;
            }
            
            var all = getAllNodes(context),
                i = -1, len = all.length;
                
            while (++i<len) {
                var cur = all[i];
                
                if (cur.nodeName.toLowerCase() === 'img') {
                    var src = cur.getAttribute('src');
                    if(!src) { continue; }
                    if (isExternal(src)) {
                        config.externalImageHandler.init(cur, src);
                    } else {
                        data(cur).realSRC = src;
                        try {
                            // Within try statement just encase there's no support....
                            cur.src = data(cur).dataURL || desatIMG(cur).toDataURL();
                        } catch(e) { config.externalImageHandler.init(cur, src); }
                    }
                    
                } else {
                    for (var pIndex = 0, pLen = config.colorProps.length; pIndex < pLen; pIndex++) {
                        var prop = config.colorProps[pIndex],
                        style = getStyle(cur, prop);
                        if (!style) {continue;}
                        if (cur.style[prop]) {
                            data(cur)[prop] = style;
                        }
                        // RGB color:
                        if (style.substring(0,4) === 'rgb(') {
                            var monoRGB = RGBtoGRAYSCALE.apply(null, style.match(/\d+/g));
                            cur.style[prop] = style = 'rgb(' + monoRGB + ',' + monoRGB + ',' + monoRGB + ')';
                            continue;
                        }
                        // Background Image:
                        if (style.indexOf('url(') > -1) {
                            var urlPatt = /\(['"]?(.+?)['"]?\)/,
                                url = style.match(urlPatt)[1];
                            if (isExternal(url)) {
                                config.externalImageHandler.init(cur, url);
                                data(cur).externalBG = true;
                                continue;
                            }
                            // data(cur).BGdataURL refers to caches URL (from preparation)
                            try {
                                var imgSRC = data(cur).BGdataURL || (function(){
                                        var temp = document.createElement('img');
                                        temp.src = url;
                                        return desatIMG(temp).toDataURL();
                                    })();
                                
                                cur.style[prop] = style.replace(urlPatt, function(_, url){
                                    return '(' + imgSRC + ')';
                                });
                            } catch(e) { config.externalImageHandler.init(cur, url); }
                        }
                    }
                }
            }
            
        };
        
        init.reset = function(context) {
            // Handle if a DOM collection is passed instead of a single el:
            if (context && context[0] && context.length && context[0].nodeName) {
                // Is a DOM collection:
                var allContexts = Array.prototype.slice.call(context),
                    cIndex = -1, cLen = allContexts.length;
                while (++cIndex<cLen) { init.reset.call(this, allContexts[cIndex]); }
                return;
            }
            context = context || document.documentElement;
            if (!document.createElement('canvas').getContext) {
                context.style.filter = 'progid:DXImageTransform.Microsoft.BasicImage(grayscale=0)';
                return;
            }
            var all = getAllNodes(context),
                i = -1, len = all.length;
            while (++i<len) {
                var cur = all[i];
                if (cur.nodeName.toLowerCase() === 'img') {
                    var src = cur.getAttribute('src');
                    if (isExternal(src)) {
                        config.externalImageHandler.reset(cur, src);
                    }
                    cur.src = data(cur).realSRC || src;
                } else {
                    for (var pIndex = 0, pLen = config.colorProps.length; pIndex < pLen; pIndex++) {
                        if (data(cur).externalBG) {
                            config.externalImageHandler.reset(cur);
                        }
                        var prop = config.colorProps[pIndex];
                        cur.style[prop] = data(cur)[prop] || '';
                    }
                }
            }
        };
        
        init.prepare = function(context) {
            
            // Handle if a DOM collection is passed instead of a single el:
            if (context && context[0] && context.length && context[0].nodeName) {
                // Is a DOM collection:
                var allContexts = Array.prototype.slice.call(context),
                    cIndex = -1, cLen = allContexts.length;
                while (++cIndex<cLen) { init.prepare.call(null, allContexts[cIndex]); }
                return;
            }
            
            // Slowly recurses through all elements
            // so as not to lock up on the user.
            
            context = context || document.documentElement;
            
            if (!document.createElement('canvas').getContext) { return; }
            
            var all = getAllNodes(context),
                i = -1, len = all.length;
            
            while (++i<len) {
                var cur = all[i];
                if (data(cur).skip) { return; }
                if (cur.nodeName.toLowerCase() === 'img') {
                    if (cur.getAttribute('src') && !isExternal(cur.src)) {
                        desatIMG(cur, true);
                    }
                    
                } else {
                    var style = getStyle(cur, 'backgroundImage');
                    if (style.indexOf('url(') > -1) {
                        var urlPatt = /\(['"]?(.+?)['"]?\)/,
                            url = style.match(urlPatt)[1];
                        if (!isExternal(url)) {
                            var temp = document.createElement('img');
                            temp.src = url;
                            desatIMG(temp, true, cur);
                        }
                    }
                }
            }
        };
        
        return init;
    
    })();
    

    这有grayscale.js的前提下,我新建了turngray_IE.js。代码如下:

    window.onload=function(){
      grayscale(document.body);
    }
    

    在需要变灰的网页代码和之间引入grayscale.js和turngray_IE.js

    <script type="text/javascript" src="../assets/js/grayscale.js" ></script>
    <script type="text/javascript" src="../assets/js/turngray_IE.js" ></script>
    

    验证是否有效果

    省略。涉及到隐私,暂不展示。我试过,无论在手机端还是PC端,无论是Android 、IOS、还是Windows的终端都OK,都有网站置灰的效果。

    不足之处

    在IE浏览器,window.onload比较消耗客户端浏览器资源,所以加载稍微迟缓。但一般看不出来。
    (声明:本人非前端开发人员,仅仅是解决问题。不喜勿喷)

    补充-在网站发布系统操作更方便

    思路:在一对多网站发布系统中,写一个文件管理功能,可以增加css和js文件以及修改代码,并将本地目录,即发布系统所在服务器网站母版目录,同步到所有ihs服务器或者其他类型的服务器。这样就不用登录每台网站服务器,每个文件去引入css和js了。节省了工作量。具体是在每个html引入以下3行:


    然后把turngray.css、grayscale.js、turngray_IE.js放到对应的目录。(相对路径根据实际项目目录来定,此处仅仅举例)
    再就是将改动的文件全部同步到各个网站服务器
    注:一对多是自定义说法,表示一个发布系统多个网站服务器

    展开全文
  • H5自适应DB科融证券官网源码是一套非常精美的H5自适应证券官方网站源码,是DB中子币科融证券的官方网站源码,目前国内已经有几家开始涉足到DB中子币科融证券团队发展中了,DB中子币在国内也有一种称呼是“天宫3号”...
  • 安米程序[新一代H5手机建站程序]是一款专注于H5手机网站/app建设的一款程序,具有免费开源,上手难度低,程序精简(程序不足1M),功能强大,不懂编程也能轻松定制自己想要的功能。后台强大的组件编写功能,可以像...
  • 逐浪CMS2 x3.8系统是逐浪软件团队年度大作,也是有史以来最大的一次构更新,我们不仅重写了全局代码、后台引擎,同时就整个底层架构进行优化,整体效率提升了三倍以上。 同时融入了新的办公系统、移动功能、H5...
  • 用户数据注册安全性

    2017-05-25 10:27:03
    http明文https加密的,有些网站登录注册是https(减少服务器后台加密计算),现在多数是https的,防止运营商拦截网站添加广告什么的,导致用户体验差。 (2)公钥加密私钥解密,支付宝h5页面的支付密码加密 纯粹...

    (1)HTTPS注册页

    http明文https加密的,有些网站登录注册是https(减少服务器后台加密计算),现在多数是https的,防止运营商拦截网站添加广告什么的,导致用户体验差。

    (2)公钥加密私钥解密,支付宝h5页面的支付密码加密

    纯粹数据加密可以采用秘钥对,用户打开页面时服务器会下发一个公钥,填写的密码和公钥加密,加密后提交给服务器,因为服务器有私钥,所以可以解出密码。

    (3)用户密码salt防止破解

    Salt+MD5加密,单纯的MD5网上有在线的解密网站,可以破解

    (4)Token有效期

    保证token不要被其他人占用

    (5)单一平台的单点登录,登录IP异常检验

    (6)用户状态权限判断

    用拦截器检验是否VIP,是否管理员,

    (7)添加验证码机制,防止爆破和批量注册

    防止黑客疯狂注册校验密码,比如忘记密码要输入手机验证码(6位数字)假设写一段代码写0到99999通过机器注册账号,总有一个是对的,那么密码就被修改。此时服务器要做校验,如果一次密码失效token设置失效。

    (8)一般情况下,登录注册信息前端后端都会进行验证

    展开全文
  • 我有两个报价两万五的前端网站,没有做后台,想拿去练手的可以我QQ1050792755 涉及到JS,H5,JQ,报价1000¥,有兴趣的可以找我谈谈

    首先,学数据库之前,我们先来认识这样一张图,这张图是数据库各组件协同工作的流程图,对我们深入了解MySQL服务器有帮助。
    在这里插入图片描述
    该流程图分为三层
    第一层为MySQL服务器,线程/连接架构非MySQL独有,服务器都有类似的架构。

    第二层内容十分广泛,大多数核心服务都在这一层,查询、解析、优化、缓存以及所有的内置函数都在这一层,所有存储引擎的功能也都是在这一层实现,如存储过程,视图,触发器等。

    第三层包涵了存储引擎,存储引擎负责数据的存储和提取,每个存储引擎都有其优势劣势,服务器通过API(应用程序接口)与存储引擎进行通信。

    优化与执行

    MySQL会解析查询,同时创建内部数据结构(解析树,B-Tree之流),之后对其进行各类优化,包括重写查询,决定表的读取顺序,选择合适的索引等。用户可以通过特殊关键字提示优化器,影响它的决策过程。也可以请求优化器解释优化过程的各个因素,让用户可以知道服务器是如何进行优化决策的,同时提供参考准则,方便用户重构查询、schema(数据库对象的集合 如表,索引,视图,存储过程等)、修改相关的配置,令应用尽可能高效运转。对于Select语句,在执行之前,服务器会现在查询缓存上查找是否有相同的查询,如果有,则不再进行解析,优化,执行的整个过程,而是直接返回查询缓存中的结果集。

    并发控制

    多个sql语句在同一时刻对数据库里面的同一条数据做修改时,总会涉及到并发的问题。MySQL在两个层面涉及到处理并发的问题,一个是服务器层,一个是存储引擎层。

    读写锁

    读锁(read lock)也叫共享锁(shared lock),读锁是共享的,单位时间内,多用户可以同时访问同一资源,与其他用户互不干扰,不会阻塞其他线程。
    写锁(write lock)也叫排他锁(Exclusive lock),非共享锁,在单位时间内,只允许一个线程对某一资源进行操作,其他写锁或者读锁会被阻塞,而无法对目标资源进行操作。
    在实际情况下,当用户在对数据进行修改时,其他用户会无法对该数据进行访问跟其他操作,因为该数据已经被写锁锁定。大部分情况下,锁的内部管理都是透明的

    锁粒度

    一种提高共享数据并发性的方式,就是让锁定的对象更具选择性,尽量只锁定需要修改的部分数据,而不去锁定全部数据。任何时候,锁定的数据越少、越精确,并发程度越高,只要相互之间不冲突即可。
    加锁需要消耗资源,锁的各种操作,包括获得锁、检测锁是否已经解除、释放锁等,都会占用资源,增加系统的开销。

    锁策略

    所谓锁策略,就是在锁的开销和数据的安全性之间寻求平衡,这种平衡当然也会影响性能。MySQL提供了多种选择,每种MySQL存储引擎都可以实现自己的所策略和锁粒度。

    锁策略—表锁(table lock)

    表锁是MySQL中最基本的表策略,并且是开销最小的策略,表锁会锁定整张表,一个用户在对表进行写操作(插入、删除、更新等)前,需要先获得写锁,这会阻塞其他用户对表的所有读写操作。只有没有写锁时,其他读取的用户才能获得读锁,读锁之间是不互相阻塞的。值得注意的是,写锁比读锁有着更高的优先级,因此,一个写锁请求可能会被插入到读锁队列的前面,相反,读锁不能插入到写锁的前面。

    锁策略—行级锁(row lock)

    行级锁可以最大程度实现并发处理,但同时也带来了最大程度的锁开销,MySQL行级锁只在存储引擎实现,服务器层完全不清楚存储引擎层的锁实现,所有的存储引擎都有自己的方式显现锁机制

    事务

    事务是一组原子性的SQL查询,或者说是独立的工作单元。如果数据库引擎能够成功地对数据库应用该组查询的全部语句,那么就执行该组查询。如果其中有任何一条语句因为崩溃或其他原因无法进行,那么所有的语句都不会执行。也就是说,事务内的语句,要么全部执行,要么全部执行失败。
    事务的ACID概念
    原子性(Atomicity),一个事务必须被视为一个不可分割的最小工作单元,整个事务中的所有操作要么全部提交成功,要么全部失败回滚,对于一个事务来说,不可能只执行其中的一部分操作。

    一致性(Consistency),数据库总是从一个一致性的状态转换到另一个一致性的状态。一致性确保了事务执行的完整性,就是说一个事务必须完整地执行才会被提交,否则将会回滚,数据都不会得到变更。

    隔离性(Isolaion),通常来说,一个事务所做的修改在最终提交前,对其他事务是不可见的。

    持久性(Durability),一旦事务提交,则其所做的修改就会被永久保存到数据库中,此时即使系统崩溃,修改的数据也不会丢失。持久性是个有点模糊的概念,因为实际上持久性也分很多不同的级别。有些持久性策略能够提供非常强的安全保障,而有些则未必。而且不可能有能做到100%的持久性保障的策略。

    事务的ACID特性可以确保银行不会弄丢你的钱。而在应用逻辑中,要实现这一点非常难,甚至可以说是不可能完成的任务。一个兼容ACID的数据库系统,需要做很多复杂但可能用户并没有觉察到的工作,才能确保ACID的实现。就像锁粒度的升级会增加系统开销一样,这种事务处理过程中额外的安全性,也会需要数据库系统做更多的额外工作。一个实现了ACID的数据库,相比没有实现ACID的数据库,通常会需要更强的CPU处理能力、更大的内存和更多的磁盘空间。

    隔离级别

    在SQL标准中定义了四种隔离级别,每一种级别都规定了一个事务中所做的修改,哪些在事务内和事务间是可见的,哪些是不可见的。较低级别的隔离通常可以执行更高的并发,系统开销也更低,隔离级别有四种,分别如下。

    未提交读(Read Uncommitted)
    在Read Uncommitted级别,事务中的修改,即使没有提交,对其他事务也都是可见的。事务可以读取未提交的数据,这也可以被称为脏读(Dirty Read)。这个级别会导致很多问题,从性能上来说,Read Uncommitted不会比其他的级别好太多,但却缺乏其他级别的很多好处,除非真的有必要的理由,在实际应用中一般很少使用。

    提交读(Read Committed)
    大多数数据库系统的默认隔离级别都是Read Committed(MySQL不是)。Read Committed满足前面提到的隔离性的简单定义:一个事务开始时,只能看见已经提交的事务所做的修改。换句话说,一个事务从开始知道提交之前,所做的任何修改对其他事务都是不可见的。这个级别有时候也叫做不可重复读(nonrepeatable read),因为两次执行同样的查询,可能会得到不一样的结果。

    可重复读(Repeatable Read),RepeaTable Read解决了脏读的问题。该级别保证了在同一个事务中多次读取同样记录的结果是一致的。但理论上,可重复读隔离级别还是无法解决另外一个幻读(Phantom Read)的问题。所谓幻读,指的是当某个事务在读取某个范围内的记录时,另外一个事务又在该范围内插入了新的记录,当之前的事务再次读取该范围的记录时,会产生缓行(Phantom Row)。InnoDB和XtraDB存储引擎通过多版本并发控制(Multiversion Concurrency Control)解决了幻读的问题。可重复度是MySQL的默认事务隔离级别。

    Serializable(可串行化),Serializable是最高的隔离级别。它通过强制事务串行执行,避免了前面说的幻读的问题。简单来说,Serializable会在读取的每一行数据上都加锁,所以可能导致大量的超时和锁争用的问题。实际应用中也很少用到这个隔离级别,只有在非常需要确保数据的一致性而且可以接受没有并发的情况下,才考虑采用该级别。

    死锁

    死锁是指两个或者多个事务在同一资源上相互占用,并请求锁定对方占用的资源,从而导致恶性循环的现象。当多个事务试图以不同的顺序锁定资源时,就可能会产生死锁。多个事务同时锁定同一个资源时,也会产生死锁。为了解决死锁问题,数据库系统实现了各种死锁检测和死锁超时机制。越复杂的系统,比如InnoDB存储引擎,越能检测到死锁的循环依赖,并立即返回一个错误。这种解决方式很有效,否则死锁会导致出现非常慢的查询。还有一种解决方式,就是当查询的时间达到锁等待超时的设定后放弃锁的请求,这种方式通常来说不太好。InnoDB目前处理死锁的方法是,将持有最少行级排他锁的事务进行回滚,这是相对比较简单的死锁回滚算法。
    锁的行为和顺序是和存储引擎相关的,以同样的顺序执行语句,有些存储引擎会产生死锁,有些则不会。死锁的产生有双重原因,有些是因为真正的数据冲突,这种情况通常很难避免,但有些则完全是由于存储引擎的实现方式导致的。死锁发生以后,只有部分或者完全回滚其中一个事务,才能打破死锁。对于事务型的系统,这是无法避免的,所以应用程序在设计时必须考虑如何处理死锁。大多数情况下只需要重新执行因死锁回滚的事务即可。

    展开全文
  • 微信模板消息发送采坑

    千次阅读 2019-03-30 15:54:57
    第三方应用(网站,管理后台系统,h5)【必须要有域名,该域名还必须配置在白名单中】用户数据和微信用户绑定,建立一对一关系, 说白了就是在自己的数据库用户表字段,来保存一个openid 具体:公众号后台配置...

    1.申请公众号

    2.新增模板(前提:认证通过)

    appid和appsecret找到,准备好

     

    3..第三方应用(网站,管理后台系统,h5)【必须要有域名,该域名还必须配置在白名单中用户数据和微信用户绑定,建立一对一关系,

    说白了就是在自己的数据库用户表加字段,来保存一个openid

    具体:公众号后台配置自定义菜单

    跳转网页这里写:

         https://open.weixin.qq.com/connect/oauth2/authorize?
         appid=xxxxxxxxx
         &redirect_uri=xxxxxxx(这里写域名下的路径(也就是要去绑定用户信息的h5页面)[记得用encode转码])
         &response_type=code
         &scope=snsapi_base
         &state=123#wechat_redirect

     

     

    上面这的域名不用加http,直接写域名

    4.程序开发,也就是上面说的域名下的路径(其实是一个请求,跳转h5页面)

    用户一点击绑定菜单,会调用3中的redirct_uri请求,跳转到h5,【此时步骤3中的就已经返回了code,在代码里直接获取】

    用户在h5提交表单后,进入新的接口(处理一些逻辑(获取到openid把第一步中的字段跟新上))

      public static JSONObject getAccessTokenAndOpenidByCode(String code) {
            String accessToken = "";
    
            String ACCESS_TOKEN_URL = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=" + appId + "&secret=" + appSecret + "&code=" + code + "&grant_type=authorization_code";
            JSONObject jsonObject = httpRequest(ACCESS_TOKEN_URL, "GET", null);
            // 如果请求成功
            if (jsonObject != null) {
                return jsonObject;
            }
            return null;
        }

    返回的json里面获取openid

    5.下面就准备发送模板消息了

    public static JSONObject sendMessageTemplate(String sendName, String sendMobile, String wxid) {
           TemplateData first = new TemplateData();
            first.setColor("#000000");
            first.setValue("配送成功!");
    //        TemplateData name = new TemplateData();
    //                    name.setColor("#0d29d0");
    //                    name.setValue("配送员:"+sendName+" 电话:"+sendMobile);
    //        TemplateData time = new TemplateData();
    //                    time.setColor("#0d29d0");
    //                    time.setValue("配送时间:"+getDateString(new Date()));
            TemplateData code = new TemplateData();
            code.setColor("#000000");
            code.setValue("配送员:" + sendName + " \n" +
                    "电话:" + sendMobile + " \n" +
                    "送达时间:" + getDateString(new Date()) + " \n" +
                    "如有疑问,请致电配送员");
            Map<String, TemplateData> templateData = new HashMap<String, TemplateData>();
    //                                templateData.put("keyword2", time);
    //                                templateData.put("keyword1", name);
            templateData.put("first", first);//这个是模板关键字,三层结构first,中间data,最后remark
            templateData.put("remark", code);
    
            WxTemplate wxTemplate = new WxTemplate();
            wxTemplate.setUrl("");
            wxTemplate.setTouser(wxid);//消息接受者
            wxTemplate.setTopcolor("#000000");
            wxTemplate.setTemplate_id(WEIXIN_TEMPLATE_CODE_USER);//消息模板id,步骤1截图中的模板id
           wxTemplate.setData(templateData);
    
            String sendMessage = sendMessage(wxTemplate);
    
            JSONObject json = JSONObject.parseObject(sendMessage);
    
            return json;
        }
    public static String sendMessage(WxTemplate wxTemplate) {
        Object accessToken = getAccessToken();
        System.out.println("获取到的token:" + accessToken);
        String reqURL = "https://api.weixin.qq.com/cgi-bin/message/template/send?access_token=" + accessToken;
        String postJsonRequest = "";
        try {
            postJsonRequest = postData(reqURL, JSON.toJSONString(wxTemplate));
            System.out.println("结果返回:" + postJsonRequest);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return postJsonRequest;
    }
       /**全局token 所有与微信有交互的前提 */
        public static String ACCESS_TOKEN;
    
        /**全局token上次获取事件 */
        public static long LASTTOKENTIME;
    
         /**因为token有个过期时间,所以需要过段时间就跟新下
         * 获取全局token方法
         * 该方法通过使用HttpClient发送http请求,HttpGet()发送请求
         * 微信返回的json中access_token是我们的全局token
         */
        public static String getAccessToken() {
            if(ACCESS_TOKEN == null || System.currentTimeMillis() - LASTTOKENTIME > 7000*1000){
                String url = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=" + appId + "&secret=" + appSecret;
                JSONObject jsonObject = httpRequest(url, "GET", null);
                ACCESS_TOKEN = (String) jsonObject.get("access_token");
                //给获取access_token时间赋值,方便下此次获取时进行判断
                LASTTOKENTIME = System.currentTimeMillis();
            }
    
            return ACCESS_TOKEN;
    
        }

     

    如果要在本地调试,则把本地的ip也新增到白名单,否则给提示不在白名单

     

    多个ip的话,用换行的形式来隔开,如下

    展开全文
  • 最新易支付源码打包

    2018-12-16 18:41:05
    功能介绍 支付⒌9更新内容 1.增加订单查询功能 2.全新的收银台页面 3.增加微信H5功能 4.增加后台自定义服务条款...3.安装源码如果有什么问题可以在网站后面/install 来安装。 4.可以对接蚂支付官方接口,后台功能多。
  • crypto-js遇到的坑

    2017-12-19 14:57:00
    最近在做H5网站,用websocket跟后台交互时,需要对数据进行加密,于是选了crypto-js组件,GitHub上api也不少,写的也清晰,但实际使用上会遇到不少坑: 加密解密时,传入的密钥key,需要转换为特定数组,不能是字符...
  • jshop短信插件修改 v1.0

    2019-10-22 03:56:21
    后台采用Thinkphp5.1框架开发,执行效率、扩展性、稳定性值得信赖,前台H5采用VUE开发,增加用户体验。增加Jshop短信接口接入说明: 1、将本插件直接覆盖原来网站中的文件,覆盖之前,建议提前备份。2、后台->控制...
  • 安米社区程序 v1.1.0

    2019-10-22 14:46:04
    安米程序[新一代H5手机建站程序]是一款专注于H5手机网站/app建设的一款程序,具有免费开源,上手难度低,程序精简(程序不足1M),功能强大,不懂编程也能轻松定制自己想要的功能。后台强大的组件编写功能,可以像...
  • 修正 触屏职位列表和pc职位列表搜索时参数后结果不一致问题;修正 修改简历后委托投递问题(都市人才网指导);修正 后台自定义发票类型不显示;修正 企业风采、附件作品待审核统计问题;修正 ie下点击首页“填简历...
  • 苍穹影视双端最新.zip

    2020-04-13 22:46:06
    全网首发,最新苍穹影视双端千月,全新后台 1. 使用N++软件批量修改默认的域名与软件名字,修改为自己的默认域名:http://gxys.502t.cn 默认软件名字:共享影视(最重要的在后边一定要看) 2. 修改config....
  • 一般不用设置即可正常工作,如果基本设置里的网站目录显示不正确,请手动修改,后面需要"/" 注意:x3.7以后的版本,第一次安装需要先进后台恢复下配置才能使用! 注意: 升级完成后请务必清空缓存,包括浏览器...
  • 5. 支持手机App网页程序扩展,自己用H5网页,嵌入到App中。 DuckChat安全的私有部署IM聊天软件 v1.1.4更新日志 新增:客服小程序 修复:站点默认好友删除无效 修复: 优化web端长链接  DuckChat是一款独立...
  • 在选色以及布局上我们进行了重新的规划,让网站表现出的营销性质更弱,突出知识商城的感觉。整体感觉更加清爽,知识的阅读体验也得到提高。 智果内容付费系统 v2.0.0 更新日志 除了界面的整体改版之外,功能上的...
  • 前台模板页面风格美化、功能流程优化完善及修复已知BUG,新增活动及微信与支付宝H5手机支付功能。 OElove主要为满足企业及个人创业者对婚恋交友类网站的自定义快速搭建需求,OELove交友网站系统基于PHP+Mysql开发的...
  • 官方网站:http://www.crmeb.com 参与开发 请提交 CRMEB。 开源版使用须知 1.允许用于个人学习、毕业设计、教学案例、公益事业; 2.如果商用必须保留版权信息,请自觉遵守; 3.禁止将本项目的代码和资源进行任何形式...
  • 获取微信小程序全局唯一后台接口调用凭据 wechat.GetAppletPaidUnionId() => 微信小程序用户支付完成后,获取该用户的 UnionId,无需用户授权 wechat.GetPublicUserInfo() => 微信公众号:获取用户基本信息 ...
  • 欢迎各位开发者把自己的项目进来~ 发 Pull Request 或 Issue 即可 (入选标准:必须是网站或App,不能是开发者工具或论坛型网站) 2. 项目有 3 种状态 开发中 已上线 已关闭或缺乏维护 ✅ ❌ 社区...

空空如也

空空如也

1 2
收藏数 22
精华内容 8
关键字:

网站h5加后台