怎样引用一个网站

Question

本帖最后由 glgxw 于 2013-12-04 10:21:40 编辑

Answer 1

iframe后的问题比较多
还有别的方法吗？期待

Answer 2

            System.Net.WebClient wc = new System.Net.WebClient();
            string html = Encoding.UTF8.GetString(wc.DownloadData("http://www.baidu.com"));
            Response.Write(html);
            Response.End();你是想这样吗？完全跟百度一模一样。

Answer 3

此方法是不是和ifram一样不能使用cookie？怎样解决

Answer 4

如果你重视SEO的话，那A网站使用Iframe是很不适合的。
既然A网站内容全部来自B，为什么不直接A网站前端程序读取B网站的数据库？

Answer 5

不重视SEO，就是访问A时，获取到的实际是B就行，并且cookie不失效

Answer 6

server.transfer("http://www.baidu.com")或者response.redirect("http://www.baidu.com")

Answer 7

<%@ WebHandler Language="C#" Class="webproxy" %>using System;
using System.Web;
using System.Net;
using System.Xml.Serialization;
public class webproxy : IHttpHandler
{
    HttpResponse Response;
    HttpRequest Request;    public Uri url;    public void ProcessRequest(HttpContext context)
    {
        this.Response = context.Response;
        this.Request = context.Request;        string qs = context.Request.Url.Query;
        if (string.IsNullOrEmpty(qs) || qs.Length < 10)
        {
            context.Response.StatusCode = 404;
            return;
        }
        ExpireProc();
         
        qs = qs.Substring(1);
        if (!qs.StartsWith("http://", StringComparison.OrdinalIgnoreCase))
        {
            Uri rdURI = GetRequestUrl(qs);
            if (System.Text.RegularExpressions.Regex.IsMatch(rdURI.AbsolutePath,
                    "\\.(js|jpg|png|gif|css|bmp)$", System.Text.RegularExpressions.RegexOptions.IgnoreCase))
            {//一般非导航页面
                this.url = rdURI;
            }
            else
            {//一般性用于导航
                Response.Redirect("?" + GetRequestUrl(qs).ToString());
                return;
            }
        }
        else
            this.url = new Uri(qs);        string reffer = null;
        if (Request.UrlReferrer != null)
        {
            reffer = Request.UrlReferrer.Query;
            if (!string.IsNullOrEmpty(reffer))
                reffer = reffer.Substring(1);
        }        HttpWebRequest web = (HttpWebRequest)WebRequest.Create(this.url);
        web.Accept = string.Join(", ", Request.AcceptTypes);
        web.Headers["Accept-Encoding"] = "gzip";        string tValue;        tValue = Request.Headers["Accept-Language"];
        if (!string.IsNullOrEmpty(tValue))
            web.Headers["Accept-Language"] = tValue;        web.AllowAutoRedirect = true;
        web.CookieContainer = Cookies;
        web.UserAgent = Request.UserAgent;
        web.Referer = reffer;
        web.AutomaticDecompression = DecompressionMethods.GZip;
        web.Timeout = 2000;
        WebResponse rsp = null;        try
        {
            rsp = web.GetResponse();
        }
        catch (WebException ex)
        {
            Response.StatusCode = (int)ex.Status;
            rsp = ex.Response;
        }
        catch (Exception ex)
        {
            Response.ContentType = "text/txtfile";
            Response.Write(ex.ToString());
            return;
        }
        
        if (rsp == null)
        {
            return;
        }
        System.Text.Encoding ec = System.Text.ASCIIEncoding.Default;
        if (!string.IsNullOrEmpty(rsp.ContentType))
        {
            Response.ContentType = rsp.ContentType;
            System.Text.RegularExpressions.Match mc = System.Text.RegularExpressions.Regex.Match(rsp.ContentType, "charset=([^;]+)");
            if (mc.Success)
                ec = System.Text.Encoding.GetEncoding(mc.Groups[1].Value);
        }
        if (rsp.Headers["Set-Cookie"] != null)
        {
            Cookies = web.CookieContainer;
        }
        
        using (System.IO.Stream stm = rsp.GetResponseStream())
        {
            string ct = rsp.ContentType;
            if (string.IsNullOrEmpty(ct))
                ct = "text/html";            if (!ct.Contains("text/css") && !ct.Contains("text/html"))
            {
                Response.Cache.SetLastModified(DateTime.Now);
                Response.Cache.SetExpires(DateTime.Now.AddMinutes(20));
                TranslateDirect(stm);
                return;
            }
            Response.Cache.SetLastModified(DateTime.Now);
            Response.Cache.SetExpires(DateTime.Now.AddMinutes(5));
            Response.ContentEncoding = ec;
            System.IO.StreamReader reader = new System.IO.StreamReader(stm, ec);
            string html = reader.ReadToEnd();
            html = System.Text.RegularExpressions.Regex.Replace(html, @"(<(a|link)[^>]+href[^\w\/\\]{1,10})", "$1webproxy.ashx?");
            html = System.Text.RegularExpressions.Regex.Replace(html, @"(<(img|script|iframe)[^>]+src[^\w\/\\]{1,10})", "$1webproxy.ashx?");
            html = System.Text.RegularExpressions.Regex.Replace(html, @"(background(|-image)\: {0,}url\([^\w\/\\]{0,1})", "$1webproxy.ashx?");            Response.Write(html);
        }    }    void TranslateDirect(System.IO.Stream stm)
    {
        Response.BufferOutput = false;
        byte[] bin = new byte[4096];
        int r;        do
        {
            r = stm.Read(bin, 0, 4096);
            if (r > 0)
            {
                if (!Response.IsClientConnected)
                    break;
                Response.OutputStream.Write(bin, 0, r);
                Response.Flush();
            }
        } while (r != 0);
    }    #region Cookies
    CookieContainer _cc = null;
    CookieContainer Cookies
    {
        get
        {
            return null;
            if (_cc != null)
                return _cc;
            string cID = Convert.ToBase64String(System.Text.ASCIIEncoding.Default.GetBytes(this.url.Host));
            cID = cID.Replace('=', '_');
            HttpCookie cook = Request.Cookies[cID];
            if (cook == null)
                return new CookieContainer();            byte[] bin = Convert.FromBase64String(cook.Value);
            if (bin == null)
                return null;
            using (System.IO.MemoryStream stm = new System.IO.MemoryStream(bin))
            {
                using (System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(stm, System.IO.Compression.CompressionMode.Decompress))
                {
                    XmlSerializer XS = new XmlSerializer(typeof(CookieContainer));
                    return (CookieContainer)XS.Deserialize(zip);
                }
            }
        }
        set
        {
            return;
            _cc = value;
            string cID = Convert.ToBase64String(System.Text.ASCIIEncoding.Default.GetBytes(this.url.Host));
            cID = cID.Replace('=', '_');
            HttpCookie cookie = new HttpCookie(cID);
            Response.Cookies.Add(cookie);
            if (value == null)
            {
                cookie.Expires = DateTime.Now.AddYears(-1);
                return;
            }            using (System.IO.MemoryStream stm = new System.IO.MemoryStream())
            {
                using (System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(stm, System.IO.Compression.CompressionMode.Compress))
                {
                    XmlSerializer XS = new XmlSerializer(typeof(CookieContainer));
                    XS.Serialize(zip, value);
                    zip.Flush();
                    cookie.Value = Convert.ToBase64String(stm.ToArray());
                    cookie.Expires = DateTime.Now.AddDays(1);
                }
            }
        }
    }
    #endregion    Uri GetRequestUrl(string offset)
    {
        Uri src = Request.UrlReferrer;
        if (src == null)
            return null;
        string qs = src.Query;
        if (string.IsNullOrEmpty(qs) || qs.Length < 10)
            return null;
        src = new Uri(qs.Substring(1));
        return new Uri(src, offset);    }
    
    /// <summary>
    /// 过期信息检查并处理
    /// </summary>
    void ExpireProc()
    {
        string t = Request.Headers["If-Modified-Since"];
        if (string.IsNullOrEmpty(t))
            return;
        DateTime last;
        if (!DateTime.TryParse(t, out last))
            return;
        if ((DateTime.Now - last).TotalMinutes > 20)
            return;
        Response.StatusCode = 304;
        Response.End();
    }    public bool IsReusable
    {
        get
        {
            return false;
        }
    }}
哥用来翻墙用的，简修改即可实现你的这个效果

Answer 8

这东西能翻墙？表示怀疑，墙会对明文的url和敏感词过滤的。只能用vpn或者ssl这样的加密方式。

Answer 9

反向代理转发，是怎样实现的？比如用ngnix

Answer 10

只有空间，不能操控服务器，能使用ngnix吗？ 

Answer 11

如果你要偷别人的东西，那么你需要费劲地去“下载、抓取”数据，并且在你的A中重新写所有页面展示。如果要显示，那么只好使用 Frame。否则的话，比如说人家B上的页面有页面重定向地址，那么直接就导航到人家B网站了，而不是停留在你要伪装的A网站。

Answer 12

这东西能翻墙？表示怀疑，墙会对明文的url和敏感词过滤的。只能用vpn或者ssl这样的加密方式。
对敏感话题不感冒，只是出去支持一下电影事业

Answer 13

不就是多域名要绑一个站点吗？
iis里直接绑上不就好了

Answer 14

A、B都是自己建的网站，由于业务需要，不能共用一个域名，这个情况比较特殊，现在就是要实现访问我的A网站，浏览到的是我的B网站的内容，怎样实现？

Answer 15

A、B不在同一台服务器上，
方案是：在A上购买一个空间，连个域名，B在另一台服务器，链接另一个域名。A网站对外公开，浏览者可以访问，B网站不让直接访问，需要通过域名访问A时，A直接把B网站返回给浏览者。

Answer 16

A、B不在同一台服务器上，所以不能A、B绑定到同一个网站。
A对外公开访问，B不让浏览器访问，只允许A网站访问获取内容，呈现给浏览器。

Answer 17

至于用户信息什么的可以用单点登录处理啊。其他的iframe就行了

Answer 18

直接把A的域名解析指向到B就好了。 楼主照你这么说根本不存在什么A网站，别人输入A网址时直接指向到B就可以了。

Answer 19

直接把A的域名解析指向到B就好了。 楼主照你这么说根本不存在什么A网站，别人输入A网址时直接指向到B就可以了。
可以这么理解，A也可以做成空壳的，输入A网址显示的实际是B的，frame不行，因为存在cookie问题。

Answer 20

直接把A的域名解析指向到B就好了。 楼主照你这么说根本不存在什么A网站，别人输入A网址时直接指向到B就可以了。
可以这么理解，A也可以做成空壳的，输入A网址显示的实际是B的，frame不行，因为存在cookie问题。
 看18楼 19楼的答案！！

Answer 21

谢谢，跳转是可以转过去，但地址也会变，这样本质上是从B直接访问了，不是从A访问出来的
在两台服务器上配两个相同的IIS，上传至IIS的文件也相同，数据库也同指向一台服务器，设置B服务器能访问问A服务器的数据库就行了。
如果以后不想麻烦同时传两份，去下载个同步软件放到A就行了。

Answer 22

谢谢，跳转是可以转过去，但地址也会变，这样本质上是从B直接访问了，不是从A访问出来的
在两台服务器上配两个相同的IIS，上传至IIS的文件也相同，数据库也同指向一台服务器，设置B服务器能访问问A服务器的数据库就行了。
如果以后不想麻烦同时传两份，去下载个同步软件放到A就行了。
同步软件是本地同步还是能服务器间数据同步？
A、B共用一个数据库是可以解决问题，这样数据库要么和A服务器一起，要么和B服务器一起，这样，交互时，不在一起的服务器查询和更新就是异地执行，网络间的传输会多，执行会慢。
有没有好的解决方法？

Answer 23

直接给这个站点同时绑定上A和B两个域名不就可以。为什么非要两台服务器？如果说B站点不是你的。你没有权限。那你可以参考小偷程序的做法。A接收访问请求后采集对应B站点页面内容替换链接路径。

Answer 24

是在不同地方的两台服务器上，A、B都是自己的服务器，为什么这样不是我能决定的，是用户的要求。
不需要考虑小偷程序。A、B两个网站我都能修改，只要能满足访问A返回的的B的内容就行。
不管修改A网站还是修改B网站，只要能实现，都可以，求帮忙了！