ssr_ssrf - CSDN
ssr 订阅
SSR是各种集换式卡牌游戏中,卡牌稀有度级别分类的一种。稀有度级别一般为 UR>SSR>SR>R> N(部分集换式卡牌游戏设定中最高级别为SSR)。不限于某个或者某几个游戏特用名词,是一种被集换式卡牌游戏广泛使用的稀有度等级分类。SSR卡牌一般获取几率为1%左右。 展开全文
SSR是各种集换式卡牌游戏中,卡牌稀有度级别分类的一种。稀有度级别一般为 UR>SSR>SR>R> N(部分集换式卡牌游戏设定中最高级别为SSR)。不限于某个或者某几个游戏特用名词,是一种被集换式卡牌游戏广泛使用的稀有度等级分类。SSR卡牌一般获取几率为1%左右。
信息
外文名
SSR
出    处
各类卡牌类手游
中文名
金色传说/特超稀有
获取概率
1%左右
source insight功能
SSR全称为superior super rare,特级超稀有。一般为集换式卡牌游戏最高稀有等级。除此之外的其他稀有级:UR:Ultra Rare极度稀有例如第五人格绿纹大触、蒸汽朋克等(某些集换式卡牌游戏里等同于SSR,甚至高于SSR)SR:Super Rare超稀有(一般低于)R:Rare稀有(一般作为协战点/友情/助战点能抽到的稀有度上限)N:Normal普通(最常见最容易到手的稀有度级别
收起全文
精华内容
参与话题
  • SSR

    千次阅读 2019-08-09 10:54:08
    什么是服务器端渲染 (SSR) 服务器将组件和获取到的数据解析生成html字符串,发送给客户端。过程同之前的php、java等的全栈开发,使用模板引擎,获取数据后解析为html字符串后,发到客户端展现。 服务器渲染的 Vue....

    前后端分离后单页面应用盛行,出现了服务端渲染的说法,其能更好的SEO

    什么是服务器端渲染 (SSR)

    • 服务器将组件和获取到的数据解析生成html字符串,发送给客户端。过程同之前的php、java等的全栈开发,使用模板引擎,获取数据后解析为html字符串后,发到客户端展现。
    • 服务器渲染的 Vue.js 应用程序,可以同时在服务器客户端上运行。

    为什么使用服务器端渲染 (SSR)

    • 更好的 SEO
      Google 和 Bing 可以很好对同步 JavaScript 应用程序进行索引。
    • 更快的内容到达时间 (time-to-content)
      无需等待所有的 JavaScript 都完成下载并执行。

    服务器端渲染 vs 预渲染 (SSR vs Prerendering)

    少数营销页面(例如 /, /about, /contact 等)的 SEO,预渲染。

    Nuxt.js通用应用框架

    一个基于 Vue.js 的服务端渲染应用框架

    流程图

    nuxt流程图

    双模式

    编译后同时生成客户端和服务端代码
    在这里插入图片描述

    • url访问地址,服务端渲染后发给客户端
      服务端渲染************************************************************************************************************
    • 页面中nuxt-link标签跳转,客户端渲染。history模式,无刷新跳转(同单页应用路由跳转)
      客户端渲染
    函数 服务端 路由更新 触发时间 其它
    nuxtServerInit 触发 不触发 store/index.js中设置
    asyncData 触发 触发 组件加载之前被调用 融合data返回
    fetch 触发 触发 渲染页面前被调用 填充(store)数据

    注意事项

    • 需要服务端渲染的数据使用asyncData获取
    • vue生命周期中获取的数据会保持客户端渲染(如下mounted中获取)
      在这里插入图片描述
    展开全文
  • ssr-win.zip

    2020-03-05 18:35:43
    首先下载好ssr-win.7z,下载链接:点我 2、将下载好的压缩包解压到桌面的某个文件夹里 3、打开下图圈中的exe文件 4、随后在系统的任务栏里找到小飞机 5、...
  • ssr、订阅内容解析

    万次阅读 2019-07-19 12:14:53
    // ssr地址解析 var ssrObj = new SSR.Server("ssr://xxx", ""); ssrObj.remarks = "ssr name"; var ssrUrl = ssrObj.GetSSRLinkForServer(); // ssr地址与订阅内容转换 var ssrUrls = new[] { "ssr:\\xxx","ssr:\\...

     

    // ssr地址解析
    var ssrObj = new SSR.Server("ssr://xxx", "");
    ssrObj.remarks = "ssr name";
    var ssrUrl = ssrObj.GetSSRLinkForServer();
    
    // ssr地址与订阅内容转换
    var ssrUrls = new[] { "ssr:\\xxx","ssr:\\xxx"};
    var subscribeContent = SSR.Subscriber.ToSubscribeStr(ssrUrls);
    var ssrUrls2 = SSR.Subscriber.FromSubscribeStr(subscribeContent);

     

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Linq;
    using System.Net;
    using System.Net.Sockets;
    using System.Security.Cryptography;
    using System.Text;
    using System.Text.RegularExpressions;
    
    namespace WebApplication1
    {
        public class SSR
        {
            /// <summary>
            /// SS、SSR地址编解码
            /// </summary>
            [Serializable]
            public class Server
            {
                public string id;
                public string server;
                public int server_port;
                public int server_udp_port;
                public string password;
                public string method;
                public string protocol;
                public string protocolparam;
                public string obfs;
                public string obfsparam;
                public string remarks_base64;
                public string group;
                public bool enable;
                public bool udp_over_tcp;
                public int latency;
                public static int LATENCY_ERROR = -2;
                public static int LATENCY_PENDING = -1;
                public static int LATENCY_TESTING = 0;
                private object protocoldata;
                private object obfsdata;
                private static Server forwardServer = new Server();
                public string remarks
                {
                    get
                    {
                        if (this.remarks_base64.Length == 0)
                        {
                            return string.Empty;
                        }
                        string result;
                        try
                        {
                            result = Base64.DecodeUrlSafeBase64(this.remarks_base64);
                        }
                        catch (FormatException)
                        {
                            string text = this.remarks_base64;
                            this.remarks = this.remarks_base64;
                            result = text;
                        }
                        return result;
                    }
                    set
                    {
                        this.remarks_base64 = Base64.EncodeUrlSafeBase64(value, true);
                    }
                }
                public void CopyServer(Server Server)
                {
                    this.protocoldata = Server.protocoldata;
                    this.obfsdata = Server.obfsdata;
                    this.enable = Server.enable;
                }
                public void CopyServerInfo(Server Server)
                {
                    this.remarks = Server.remarks;
                    this.group = Server.group;
                }
                public static Server GetForwardServerRef()
                {
                    return Server.forwardServer;
                }
                public string FriendlyName()
                {
                    if (string.IsNullOrEmpty(this.server))
                    {
                        return "New server";
                    }
                    if (string.IsNullOrEmpty(this.remarks_base64))
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            "[",
                            this.server,
                            "]:",
                            this.server_port
                            });
                        }
                        return this.server + ":" + this.server_port;
                    }
                    else
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            this.remarks,
                            " ([",
                            this.server,
                            "]:",
                            this.server_port,
                            ")"
                            });
                        }
                        return string.Concat(new object[]
                        {
                        this.remarks,
                        " (",
                        this.server,
                        ":",
                        this.server_port,
                        ")"
                        });
                    }
                }
                public string HiddenName(bool hide = true)
                {
                    if (string.IsNullOrEmpty(this.server))
                    {
                        return "New server";
                    }
                    string text = this.server;
                    if (hide)
                    {
                        text = ServerName.HideServerAddr(this.server);
                    }
                    if (string.IsNullOrEmpty(this.remarks_base64))
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            "[",
                            text,
                            "]:",
                            this.server_port
                            });
                        }
                        return text + ":" + this.server_port;
                    }
                    else
                    {
                        if (this.server.IndexOf(':') >= 0)
                        {
                            return string.Concat(new object[]
                            {
                            this.remarks,
                            " ([",
                            text,
                            "]:",
                            this.server_port,
                            ")"
                            });
                        }
                        return string.Concat(new object[]
                        {
                        this.remarks,
                        " (",
                        text,
                        ":",
                        this.server_port,
                        ")"
                        });
                    }
                }
                public Server Clone()
                {
                    return new Server
                    {
                        server = this.server,
                        server_port = this.server_port,
                        password = this.password,
                        method = this.method,
                        protocol = this.protocol,
                        obfs = this.obfs,
                        obfsparam = this.obfsparam ?? "",
                        remarks_base64 = this.remarks_base64,
                        group = this.group,
                        enable = this.enable,
                        udp_over_tcp = this.udp_over_tcp,
                        id = this.id,
                        protocoldata = this.protocoldata,
                        obfsdata = this.obfsdata
                    };
                }
                public Server()
                {
                    this.server = "server host";
                    this.server_port = 8388;
                    this.method = "aes-256-cfb";
                    this.protocol = "origin";
                    this.protocolparam = "";
                    this.obfs = "plain";
                    this.obfsparam = "";
                    this.password = "0";
                    this.remarks_base64 = "";
                    this.group = "FreeSSR-public";
                    this.udp_over_tcp = false;
                    this.enable = true;
                    this.latency = Server.LATENCY_PENDING;
                    byte[] array = new byte[16];
                    Utils.RandBytes(array, array.Length);
                    this.id = BitConverter.ToString(array).Replace("-", "");
                }
                public Server(string ssURL, string force_group) : this()
                {
                    if (ssURL.StartsWith("ss://", StringComparison.OrdinalIgnoreCase))
                    {
                        this.ServerFromSS(ssURL, force_group);
                        return;
                    }
                    if (ssURL.StartsWith("ssr://", StringComparison.OrdinalIgnoreCase))
                    {
                        this.ServerFromSSR(ssURL, force_group);
                        return;
                    }
                    throw new FormatException();
                }
                public bool isMatchServer(Server server)
                {
                    return this.server == server.server && this.server_port == server.server_port && this.server_udp_port == server.server_udp_port && this.method == server.method && this.protocol == server.protocol && this.protocolparam == server.protocolparam && this.obfs == server.obfs && this.obfsparam == server.obfsparam && this.password == server.password && this.udp_over_tcp == server.udp_over_tcp;
                }
                private Dictionary<string, string> ParseParam(string param_str)
                {
                    Dictionary<string, string> dictionary = new Dictionary<string, string>();
                    string[] array = param_str.Split(new char[]
                    {
                    '&'
                    });
                    string[] array2 = array;
                    for (int i = 0; i < array2.Length; i++)
                    {
                        string text = array2[i];
                        if (text.IndexOf('=') > 0)
                        {
                            int num = text.IndexOf('=');
                            string key = text.Substring(0, num);
                            string value = text.Substring(num + 1);
                            dictionary[key] = value;
                        }
                    }
                    return dictionary;
                }
                public void ServerFromSSR(string ssrURL, string force_group)
                {
                    Match match = Regex.Match(ssrURL, "ssr://([A-Za-z0-9_-]+)", RegexOptions.IgnoreCase);
                    if (!match.Success)
                    {
                        throw new FormatException();
                    }
                    string text = Base64.DecodeUrlSafeBase64(match.Groups[1].Value);
                    Dictionary<string, string> dictionary = new Dictionary<string, string>();
                    int num = text.IndexOf("?");
                    if (num > 0)
                    {
                        dictionary = this.ParseParam(text.Substring(num + 1));
                        text = text.Substring(0, num);
                    }
                    if (text.IndexOf("/") >= 0)
                    {
                        text = text.Substring(0, text.LastIndexOf("/"));
                    }
                    Regex regex = new Regex("^(.+):([^:]+):([^:]*):([^:]+):([^:]*):([^:]+)");
                    Match match2 = regex.Match(text);
                    if (match2 == null || !match2.Success)
                    {
                        throw new FormatException();
                    }
                    this.server = match2.Groups[1].Value;
                    this.server_port = int.Parse(match2.Groups[2].Value);
                    this.protocol = ((match2.Groups[3].Value.Length == 0) ? "origin" : match2.Groups[3].Value);
                    this.protocol = this.protocol.Replace("_compatible", "");
                    this.method = match2.Groups[4].Value;
                    this.obfs = ((match2.Groups[5].Value.Length == 0) ? "plain" : match2.Groups[5].Value);
                    this.obfs = this.obfs.Replace("_compatible", "");
                    this.password = Base64.DecodeStandardSSRUrlSafeBase64(match2.Groups[6].Value);
                    if (dictionary.ContainsKey("protoparam"))
                    {
                        this.protocolparam = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["protoparam"]);
                    }
                    if (dictionary.ContainsKey("obfsparam"))
                    {
                        this.obfsparam = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["obfsparam"]);
                    }
                    if (dictionary.ContainsKey("remarks"))
                    {
                        this.remarks = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["remarks"]);
                    }
                    if (dictionary.ContainsKey("group"))
                    {
                        this.group = Base64.DecodeStandardSSRUrlSafeBase64(dictionary["group"]);
                    }
                    else
                    {
                        this.group = "";
                    }
                    if (dictionary.ContainsKey("uot"))
                    {
                        this.udp_over_tcp = (int.Parse(dictionary["uot"]) > 0);
                    }
                    if (dictionary.ContainsKey("udpport"))
                    {
                        this.server_udp_port = int.Parse(dictionary["udpport"]);
                    }
                    if (!string.IsNullOrEmpty(force_group))
                    {
                        this.group = force_group;
                    }
                }
                public void ServerFromSS(string ssURL, string force_group)
                {
                    Regex regex = new Regex("^(?i)ss://([A-Za-z0-9+-/=_]+)(#(.+))?", RegexOptions.IgnoreCase);
                    Regex regex2 = new Regex("^((?<method>.+):(?<password>.*)@(?<hostname>.+?):(?<port>\\d+?))$", RegexOptions.IgnoreCase);
                    Match match = regex.Match(ssURL);
                    if (!match.Success)
                    {
                        throw new FormatException();
                    }
                    string value = match.Groups[1].Value;
                    match = regex2.Match(Encoding.UTF8.GetString(Convert.FromBase64String(value.PadRight(value.Length + (4 - value.Length % 4) % 4, '='))));
                    this.protocol = "origin";
                    this.method = match.Groups["method"].Value;
                    this.password = match.Groups["password"].Value;
                    this.server = match.Groups["hostname"].Value;
                    this.server_port = int.Parse(match.Groups["port"].Value);
                    if (!string.IsNullOrEmpty(force_group))
                    {
                        this.group = force_group;
                        return;
                    }
                    this.group = "";
                }
                public string GetSSLinkForServer()
                {
                    string s = string.Concat(new object[]
                    {
                    this.method,
                    ":",
                    this.password,
                    "@",
                    this.server,
                    ":",
                    this.server_port
                    });
                    string str = Convert.ToBase64String(Encoding.UTF8.GetBytes(s)).Replace("=", "");
                    return "ss://" + str;
                }
                public string GetSSRLinkForServer()
                {
                    string str = string.Concat(new object[]
                    {
                    this.server,
                    ":",
                    this.server_port,
                    ":",
                    this.protocol,
                    ":",
                    this.method,
                    ":",
                    this.obfs,
                    ":",
                    Base64.EncodeUrlSafeBase64(this.password, true)
                    });
                    string text = "obfsparam=" + Base64.EncodeUrlSafeBase64(this.obfsparam ?? "", true);
                    if (!string.IsNullOrEmpty(this.protocolparam))
                    {
                        text = text + "&protoparam=" + Base64.EncodeUrlSafeBase64(this.protocolparam, true);
                    }
                    if (!string.IsNullOrEmpty(this.remarks))
                    {
                        text = text + "&remarks=" + Base64.EncodeUrlSafeBase64(this.remarks, true);
                    }
                    if (!string.IsNullOrEmpty(this.group))
                    {
                        text = text + "&group=" + Base64.EncodeUrlSafeBase64(this.group, true);
                    }
                    if (this.udp_over_tcp)
                    {
                        text += "&uot=1";
                    }
                    if (this.server_udp_port > 0)
                    {
                        text = text + "&udpport=" + this.server_udp_port.ToString();
                    }
                    string str2 = Base64.EncodeUrlSafeBase64(str + "/?" + text, true);
                    return "ssr://" + str2;
                }
                public bool isEnable()
                {
                    return this.enable;
                }
                public void setEnable(bool enable)
                {
                    this.enable = enable;
                }
                public object getObfsData()
                {
                    return this.obfsdata;
                }
                public void setObfsData(object data)
                {
                    this.obfsdata = data;
                }
                public object getProtocolData()
                {
                    return this.protocoldata;
                }
                public void setProtocolData(object data)
                {
                    this.protocoldata = data;
                }
                public void tcpingLatency()
                {
                    List<double> list = new List<double>();
                    TcpClient tcpClient = new TcpClient();
                    Stopwatch stopwatch = new Stopwatch();
                    stopwatch.Start();
                    try
                    {
                        Dns.GetHostAddresses(this.server);
                    }
                    catch (Exception)
                    {
                        this.latency = Server.LATENCY_ERROR;
                        return;
                    }
                    IAsyncResult asyncResult = tcpClient.BeginConnect(this.server, this.server_port, null, null);
                    if (asyncResult.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(2.0)))
                    {
                        stopwatch.Stop();
                        list.Add(stopwatch.Elapsed.TotalMilliseconds);
                    }
                    else
                    {
                        stopwatch.Stop();
                    }
                    try
                    {
                        tcpClient.Close();
                    }
                    catch (Exception)
                    {
                    }
                    if (list.Count != 0)
                    {
                        this.latency = (int)list.Average();
                        return;
                    }
                    this.latency = Server.LATENCY_ERROR;
                }
            }
    
            /// <summary>
            /// SS、SSR订阅内容生成
            /// </summary>
            public static class Subscriber
            {
                /// <summary>
                /// 将多个ssr地址转换为订阅内容
                /// </summary>
                /// <param name="ssrs">ssr地址列表</param>
                /// <returns></returns>
                public static string ToSubscribeStr(IEnumerable<string> ssrs)
                {
                    // 多个ssr地址用换行符分割,最后用base64编码
                    var str = string.Join("\r\n", ssrs);
                    var base64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(str));
                    return base64;
                }
    
                /// <summary>
                /// 从订阅内容中获取ssr地址列表
                /// </summary>
                /// <param name="subscribeContent">ssr订阅内容</param>
                /// <returns>ssr地址列表</returns>
                public static List<string> FromSubscribeStr(string subscribeContent)
                {
                    var str = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(subscribeContent));
                    var ssrs = str.Split("\r\n".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
                        .ToList()
                        .FindAll(m => m.StartsWith("ss", StringComparison.InvariantCultureIgnoreCase));
                    return ssrs;
                }
            }
    
            private static class Base64
            {
                public static string DecodeBase64(string val)
                {
                    return Encoding.UTF8.GetString(Base64.DecodeBase64ToBytes(val));
                }
                public static byte[] DecodeBase64ToBytes(string val)
                {
                    string s = val.PadRight(val.Length + (4 - val.Length % 4) % 4, '=');
                    return Convert.FromBase64String(s);
                }
                public static string EncodeUrlSafeBase64(byte[] val, bool trim)
                {
                    if (trim)
                    {
                        return Convert.ToBase64String(val).Replace('+', '-').Replace('/', '_').TrimEnd(new char[]
                        {
                        '='
                        });
                    }
                    return Convert.ToBase64String(val).Replace('+', '-').Replace('/', '_');
                }
                public static byte[] DecodeUrlSafeBase64ToBytes(string val)
                {
                    string s = val.Replace('-', '+').Replace('_', '/').PadRight(val.Length + (4 - val.Length % 4) % 4, '=');
                    return Convert.FromBase64String(s);
                }
                public static string EncodeUrlSafeBase64(string val, bool trim = true)
                {
                    return Base64.EncodeUrlSafeBase64(Encoding.UTF8.GetBytes(val), trim);
                }
                public static string DecodeUrlSafeBase64(string val)
                {
                    return Encoding.UTF8.GetString(Base64.DecodeUrlSafeBase64ToBytes(val));
                }
                public static string DecodeStandardSSRUrlSafeBase64(string val)
                {
                    return Encoding.UTF8.GetString(Base64.DecodeUrlSafeBase64ToBytes(val));
                }
            }
    
            private static class ServerName
            {
                public static string HideServerAddr(string addr)
                {
                    string result = addr;
                    IPAddress iPAddress;
                    bool flag = IPAddress.TryParse(addr, out iPAddress);
                    if (flag)
                    {
                        char separator;
                        if (AddressFamily.InterNetwork == iPAddress.AddressFamily)
                        {
                            separator = '.';
                        }
                        else
                        {
                            separator = ':';
                        }
                        result = ServerName.HideAddr(addr, separator);
                    }
                    else
                    {
                        int num = addr.IndexOf('.', 1);
                        if (num > 0)
                        {
                            result = "*" + addr.Substring(num);
                        }
                    }
                    return result;
                }
                private static string HideAddr(string addr, char separator)
                {
                    string text = "";
                    string[] array = addr.Split(new char[]
                    {
                    separator
                    });
                    string text2 = array[0];
                    string text3 = array[array.Length - 1];
                    if (0 < text2.Length)
                    {
                        text = text2 + separator.ToString();
                    }
                    text += "**";
                    if (0 < text3.Length)
                    {
                        text = text + separator.ToString() + text3;
                    }
                    return text;
                }
            }
    
            private static class Utils
            {
                public static void RandBytes(byte[] buf, int length)
                {
                    byte[] array = new byte[length];
                    RNGCryptoServiceProvider rNGCryptoServiceProvider = new RNGCryptoServiceProvider();
                    rNGCryptoServiceProvider.GetBytes(array);
                    array.CopyTo(buf, 0);
                }
            }
        }
    }
    

     

    展开全文
  • 什么是SSR

    2020-01-18 14:32:40
    SSR是 Server-Side Rendering(服务器端渲染)的缩写,简单的理解就是将平时写的组件,页面通过服务器生成html字符串,再发送到浏览器,最后将静态标记,混合为客户端上交互的应用程序 ...

    SSR是 Server-Side Rendering(服务器端渲染)的缩写,简单的理解就是将平时写的组件,页面通过服务器生成html字符串,再发送到浏览器,最后将静态标记,混合为客户端上交互的应用程序

    接下来我们使用node简单的写个服务端渲染的例子:
    首先创建一个项目文件夹:
    1,初始化项目:yarn init -y
    2,下载对应的依赖包:
    yarn add -D koa koa-router koa-ejs
    3,在项目文件夹中创建app.js和一个template文件夹

    在这里插入图片描述
    4,app.js的代码

    const Koa = require('koa');
    const Router = require('koa-router');
    const path = require('path');
    const ejs = require('koa-ejs');
    
    const app = new Koa()
    const router = new Router()
    
    ejs(app, {
        root: path.join(__dirname, 'template'),
        layout: false,
        viewExt: 'ejs',
        cache: false,
        debug: false
    });
    
    router.get('/', async ctx => {
        await ctx.render('index', {
            title: 'test',
            arr: [
                {name: '小红', age: 12},
                {name: '小明', age: 23}
            ]
        })
    })
    
    app.use(router.routes())
    
    app.listen(3000)
    

    然后在template中创建index.ejs,index.ejs中的代码为:

    <!DOCTYPE html>
    <html>
    	<head>
    		<meta charset="utf-8">
    		<title><%= title %></title>
    	</head>
    	<body>
            <div>
                <%= title %>
            </div>
            <ul>
                <% arr.forEach(item => { %>
                    <li>
                        <span><%= item.name %></span> 
                        <span><%= item.age %></span>
                    </li>
                <%}) %>
            </ul>
            
    	</body>
    </html>
    
    

    接下来我们使用node app.js运行项目,在本地浏览器访问:http://localhost:3000/,就会看到如下页面
    在这里插入图片描述
    这个页面就是我们通过服务器渲染的页面
    通过服务器渲染的页面的优点和缺点可以看下面这个网址:
    https://www.jianshu.com/p/fcb98533bc18

    展开全文
  • 这个是ssr脚本的备用下载地址。该脚本亲测2020-3-13可用,如博客中正式使用地址无效后,可下载该脚本进行使用。但后续可能不会更新,见谅。这下载积分会自动增加,这样就很尴尬。。。
  • ssr与csr

    2020-10-15 20:34:27
    页面的两种生成方式 用户从浏览器地址栏中输入地址访问服务器上的页面时,服务器可以用两种不同的策略来生成这个页面。 打开给出的示意代码,观察效果。 (1)服务器端渲染Server Side Render ...

    页面的两种生成方式

    用户从浏览器地址栏中输入地址访问服务器上的页面时,服务器可以用两种不同的策略来生成这个页面。

    打开给出的示意代码,观察效果。

    (1)服务器端渲染Server Side Render

    • 渲染是指:从数据到dom的过程(从json到html结构)
    • 数据到dom的过程是发生在服务器端
    • 客户端浏览器在地址栏中输入网页的地址,取回来的就是html页面。

    (2)客户器端渲染 Client Side Render

    • 渲染是指:数据到dom的过程 (从json到html结构)
    • 数据到dom的过程是发生在客户端浏览器
    • 客户端浏览器在地址栏中输入网页的地址,取回来的只是html骨架,
    • 再去发ajax请求,取回来数据,再显示到页面上(用vue,arttemplate,模板字符串等技术)

    小结

    • ssr:服务器端渲染。数据组装(从json—>dom结果)的过程是发生在服务器上的。客户端取回来的是有数据页面。
    • csr:客户端渲染。数据组装(从json—>dom结果)的过程是发生客户端(浏览器)的。主要是通过ajax取数据,再用模板技术(arttemplate,vue…)来渲染。

    SEO与爬虫

    客户端渲染技术对SEO不友好,爬虫无法获取有效内容!

    什么是SEO

    Search Engine Optimization ,搜索引擎优化。我们开发的网页肯定希望被更多人的知道,而推广自已的网页的方式之一是借助搜索引擎的力量,让其它人在百度中搜索某个关键字时就能找到你的网页。

    那么,百度是如何得知http://xxxx.com/abc这个页面中有关键字javascript的呢?

    百度服务器会使用一些程序来获取网页的内容,分析内容,以提取出关键字,便 于在搜索时能找到网页。 这个过程一般称为爬虫。

    SEO的目标是更明确地告诉百度,你的网页上的内容,以便更好地被收录。

    爬虫

    我们平常上网都是在浏览器中请求网页地址,而爬虫代码是通过代码的方式去请求网页地址。

    步骤:

    1. 创建一个.js文件(假设名字是spider.js)内容如下:

      // 引入http模块
      const http = require("http")
      
      // 定义要爬虫程序 访问的 网页
      let url = "http://localhost:8080/index_csr.html"
      
      // let url = "http://localhost:8080/index_ssr.html"
      
      // 用http模块中的get方法去请求 url 这个网页,把请求到的结果        显示出来。
      http.get(url, (res) => {
      let result = ""
      res.setEncoding('utf8');
        res.on('data', (chunk) => {
          result += chunk
        });
       res.on('end', () => {
         console.log(`爬虫得到的数据是: ${result}`);
       });
      });
      
    2. 运行js文件
      node spider.js
      这一段代码会去请求代码中url指定的网页(可在这里下载运行示例代码),并打印出结果。

    3. 小结
      对于采用客户端渲染的网页:爬虫程序无法获取有效的数据。(因为有效的数据是通过ajax在客户端发出来,去取回来的)
      对于采用服务器端渲染的网页:爬虫程序可以获取有效的数据。(因为获取的内容就已经包含数据)

    客户端渲染与服务器端渲染的区别

    客户器渲染(通过ajax求数据)

    优点 缺点
    适合前后端分离开发,方便维护,单页应用(SPA)中几乎都是客户端渲染 首屏加载慢,不利于 SEO

    服务器渲染

    优点 缺点
    响应速度快,有利于 SEO 前后端代码混合在一起,难以开发和维护,不适合进行前后端分离开发

    我们使用vue开发的的项目都是典型的SPA(单页面应用程序single page application),是标准的前后端分离的,很显然是属于客户端渲染的范畴。

    • 好处:页面导航不用刷新整个页面,体验好,有利于前后端分离开发
    • 缺点:不利于 SEO(因为单页面应用中都是使用客户端渲染的方式),还有首次响应慢(第1次要加载大量的公共资源)

    是否有相对折中的解决方案,或者是两全其美的解决方案呢?

    Vue的SSR介绍及示例演示

    Vue的SSR文档 : https://ssr.vuejs.org/zh/

    Vue.js 是构建客户端应用程序的框架。默认情况下,可以在浏览器中输出 Vue 组件,进行生成 DOM 和操作 DOM。然而,也可以将同一个组件渲染为服务器端的 HTML 字符串,将它们直接发送到浏览器,最后将这些静态标记"激活"为客户端上完全可交互的应用程序。

    • 学习vue-server-renderer
    • 在服务器端使用-server-renderer

    创建项目( nodejs)

    创建一个名为vuessr的空目录进入,并运行:

    npm init --yes
    

    来做初始化。

    安装依赖

    参考

    npm install vue vue-server-renderer --save
    

    示例:在node代码使用vue渲染数据

    新建文件为01.js,内容如下:

    const Vue = require('vue')
    // 第 1 步:创建一个 vue实例
    const app = new Vue({
      template: `<div>{{title}}</div>`,
      data:{
    	  title:"hello,vue ssr!"
      }
    })
    
    // 第 2 步:创建一个 renderer
    const renderer = require('vue-server-renderer').createRenderer()
    
    // 第 3 步:将 Vue 实例渲染为 HTML
    // 方法一:回调函数
    renderer.renderToString(app, (err, html) => {
      if (err) throw err
      console.log(html)
      // => <div data-server-rendered="true">Hello World</div>
    })
    
    // 方法二:promise
    // 在 2.5.0+,如果没有传入回调函数,则会返回 Promise:
    renderer.renderToString(app).then(html => {
      console.log(html)
    }).catch(err => {
      console.error(err)
    })
    

    运行结果:

    node 01.js
    

    输出结果如下:

    <div data-server-rendered="true">hello,vue ssr!</div>
    <div data-server-rendered="true">hello,vue ssr!</div>
    

    小结:

    vue-server-renderer就可以把Vue实例解析成 它对应的dom结构

    示例:与服务器功能集成

    目标:

    请求网页http://localhost:3000/index.html,在服务器端使用vue-server-renderer来渲染生成html文档,并返回。

    涉及npm包:

    • express(安装express) npm i express
    • vue, vue-server-renderer

    创建02.js,代码如下:

    /**
     * 目标: 用户输入http://localhost:3000/index.html
     * 在服务器使用vue-server-renderer来把vue实例渲染生成html文档,并返回
     *
     * 1) 先安装express
     */
    
    const express = require('express')
    
    const app = express()
    const Vue = require('vue')
    app.get('/index.html',(req, res) => {
      // 1. 创建vue实例
      const vm = new Vue({
        template: `
          <div>
            <h2>{{title}}</title></h2>
            <div v-for="item in list">
              {{item.author}} - {{item.content}}
            </div>
          </div>
        ` ,
        data: {
          title: 'vue ssr',
          list: [{author:"李白",content:"举杯邀明月"},
            {author:"杜甫",content:"喝酒不开车"},
            {author:"杜甫",content:"喝酒不开车"}]
        }
      })
      // res.send('ok')
      // 2. 创建一个renderer
      const renderer = require('vue-server-renderer').createRenderer()
    
      // 3. 渲染:把vue实例渲染成HTML字符串
      renderer.renderToString(vm, (err, html) => {
        if (err) {
          console.log(err)
        } else {
          res.send(html)
        }
      })
    })
    app.listen(3000, ()=>{
      console.log('3000.....')
    })
    

    运行

    node 02.js

    访问:

    http://localhost:3000/index.html

    • 小结:
      在服务器使用vue,通过***vue-server-render***包,来把vue实例转成html字符串,再返回给客户端,这就是用vue技术的ssr。
    展开全文
  • SSR(服务端渲染)

    千次阅读 2018-10-21 13:10:50
    前端面试题之SSR 客户端渲染: 在服务端放了一个html 页面,里面有 客户端发起请求,服务端把页面(响应的是字符串)发送过去,客户端从上到下依次解析,如果在解析的过程中,发现ajax 请求,再次像服务器发送新的...
  • SSE,SSR,SSE 的关系

    万次阅读 2019-06-12 10:20:53
    一、SSE(和方差) 该统计参数计算的是拟合数据和原始数据对应点的误差的平方和,计算公式如下 SSE越接近于0,说明模型选择和拟合更好,数据预测也越成功。接下来的MSE和RMSE因为和SSE是同出一宗,所以效果一样二...
  • 不同SSR特性之间的优劣简要概述

    千次阅读 2019-05-17 14:42:15
    如果阁下对SSR特性(协议插件和混淆插件)以及加密方式不了解,建议先选择默认方式,并阅读此文章后再决定具体选择何种协议。 加密方式 目前rixCloud 支持以下的加密方式 CHACHA20(默认) AES-128-CFB AES-256-...
  • VueSSR的一些理解和详细配置

    千次阅读 2019-07-19 21:28:08
    概念 流程图 这是具体的流程图,如何实现,后续配置会详解 编译图解 结合上面的流程图来理解编译的过程图,因为服务端渲染只是一个可以等待异步数据的预渲染,最终用户交互还是需要Client entry生成的js来控制,这...
  • 最近有小伙伴在后台给我留言:如何才能成功通过大厂面试,进入大厂,拿到高薪offer? 关于这些问题,有一个人最有发言权,因为在他的帮助下,不少小伙伴都梦想成真了! 他是谁? 他——九叔,九叔有多牛: ...
  • 共用部分 import React ,{useState} from 'react' import {connect} from 'react-redux' import {getIndexList} from '../store/index' const Index = (props) => { let [count,setCount] = useState(1) ...
  • 15分钟学会vue项目改造成SSR

    千次阅读 多人点赞 2019-12-16 18:01:24
    15分钟学会vue项目改造成SSR Ps:网上看了好多服务器渲染的例子,基本都是从0开始的,用Nuxt或者vue官网推荐的ssr方案(vue-server-renderer),但是我们在开发过程中基本上是已经有了现有的项目了,我们所要做的是...
  • 使用python建立SSR订阅服务器

    万次阅读 2019-03-23 11:11:40
    使用python建立SSR服务器 SSR链接解析 订阅服务器的文本格式 搭建服务器运行Python Base64 编码原理
  • 让vue-cli初始化后的项目集成支持SSR

    万次阅读 2017-11-14 18:56:23
    http://blog.myweb.kim/vue/%E8%AE%A9vue-cli%E5%88%9D%E5%A7%8B%E5%8C%96%E5%90%8E%E7%9A%84%E9%A1%B9%E7%9B%AE%E9%9B%86%E6%88%90%E6%94%AF%E6%8C%81SSR/?utm_campaign=ligang&utm_source=csdn&
  • scrapy爬取ssr链接

    千次阅读 2019-08-24 21:13:23
    title: scrapy爬取ssr链接 date: 2019-08-23 15:53:58 categories: 爬虫 tags: scrapy selenium cover: https://www.github.com/OneJane/blog/raw/master/小书匠/3d21604af4ece8292ae728500ce2c4f7_hd.jpg 基于...
  • electron-ssr

    2019-10-13 19:46:46
    electron-ssr-0.2.6.AppImage原网站的github已经关闭,但有人做了备份,不过防止备份的也删了大家还是最好自己下一个保险。安装时直接双击即可,如果没反应右键打开属性,勾选可执行文件即可,在双击即可正常安装。
  • 一、服务端渲染   1.基本概念 Vue.js 是构建客户端应用程序的框架。默认情况下,可以在浏览器中输出 Vue 组件,进行生成 DOM 和操作 DOM。...激活"为客户端上完全可交互的应用程序。...(1)更好的 SEO,由于搜索...
  • 基于VUE的SSR技术

    千人学习 2017-06-20 00:41:47
    随着VUE的发展,国内很多网络产品选用了VUE作为开发,但国内百度蜘蛛无内存抓取严重了影响了VUE的发展,VUE在2017年也大力的推荐SSR,相关产品也出现了NUXT等部署机制,本课程结合VUE讲解SSR模式,需要有VUE2.0基础...
  • SSR分子标记

    2013-03-01 11:01:42
    SSR分子标记
1 2 3 4 5 ... 20
收藏数 17,576
精华内容 7,030
关键字:

ssr