精华内容
下载资源
问答
  • 常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术。 正向代理 一般情况下,如果没有特别说明,代理技术默认说的是正向...

    什么是代理?

    代理服务技术是一门很古老的技术,是在互联网早期出现就使用的技术。一般实现代理技术的方式就是在服务器上安装代理服务软件,让其成为一个代理服务器,从而实现代理技术。代理本质上是一个服务器,可以类比为一个中介。为了A访问到B,中间插入一个 C,C 就是代理。常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术。

    正向代理

    一般情况下,如果没有特别说明,代理技术默认说的是正向代理技术。关于正向代理的概念如下:
    正向代理(forward)是一个位于客户端【用户A】和原始服务器(origin server)【服务器B】之间的服务器【代理服务器Z】,为了从原始服务器取得内容,用户A向代理服务器Z发送一个请求并指定目标(服务器B),然后代理服务器Z向服务器B转交请求并将获得的内容返回给客户端。客户端必须要进行一些特别的设置才能使用正向代理。

    主要应用

    fanqiang上网

    主要作用

    1. 正向代理的典型用途是为在防火墙内的局域网客户端提供访问Internet的途径。
    2. 正向代理还可以使用缓冲特性(由mod_cache提供)减少网络使用率。
    3. 代理可以记录用户访问记录(上网行为管理),对外隐藏用户信息。

    反向代理

    反向代理正好与正向代理相反,对于客户端而言代理服务器就像是原始服务器,并且客户端不需要进行任何特别的设置。客户端向反向代理的命名空间(name-space)中的内容发送普通请求,接着反向代理将判断向何处(原始服务器)转交请求,并将获得的内容返回给客户端。
    反向代理对外的表现都是透明的,客户不知道自己访问的是代理服务器,客户端也不需要任何配置就可以访问。当我们配置好代理服务器后,反向代理(Reverse Proxy)实际运行方式是指以代理服务器来接受internet上的连接请求,然后将请求转发给内部网络上的服务器,并将从服务器上得到的结果返回给internet上请求连接的客户端,此时代理服务器对外就表现为一个服务器。

    主要应用

    安全、负载均衡方面的常用配置

    主要作用

    1. 保证证内网的安全,可以使用反向代理提供WAF功能,阻止web攻击,大型网站,通常将反向代理作为公网访问地址,Web服务器是内网。
    2. 负载均衡,通过反向代理服务器来优化网站的负载。

    透明代理

    如果把正向代理、反向代理和透明代理按照人类血缘关系来划分的话。那么正向代理和透明代理是很明显堂亲关系,而正向代理和反向代理就是表亲关系了。透明代理的意思是客户端根本不需要知道有代理服务器的存在,它改编你的request fields(报文),并会传送真实IP。注意,加密的透明代理则是属于匿名代理,意思是不用设置使用代理了。透明代理实践的例子就是时下很多公司使用的行为管理软件。

    用户A和用户B并不知道行为管理设备充当透明代理行为,当用户A或用户B向服务器A或服务器B提交请求的时候,透明代理设备根据自身策略拦截并修改用户A或B的报文,并作为实际的请求方,向服务器A或B发送请求,当接收信息回传,透明代理再根据自身的设置把允许的报文发回至用户A或B,如上图,如果透明代理设置不允许访问服务器B,那么用户A或者用户B就不会得到服务器B的数据。

    主要应用

    防火墙、行为管理软件

    主要作用

    透明代理的意思是客户端根本不需要知道有代理服务器的存在,它改变你的request fields(报文),并会传送真实IP,多用于路由器的NAT转发中。注意,加密的透明代理则是属于匿名代理,意思是不用设置使用代理了,例如Garden 2程序。

    正向代理和反向代理区别

    1. 正向代理中 ,proxy和client同属一个lan,对server透明。正向代理需要配置在client端;
    2. 反向代理中,proxy和server同属一个lan,对client透明。 反向代理需要配置在proxy端;
    3. 实际上proxy在两种代理中做的事都是代为请求和响应,不过从结构上看正好左右相反,故称为正反向代理。

    参考

    • https://www.cnblogs.com/ranyonsue/p/11187588.html
    • https://www.cnblogs.com/-abm/p/9894289.html

    结语

    欢迎关注微信公众号『码仔zonE』,专注于分享Java、云计算相关内容,包括SpringBoot、SpringCloud、微服务、Docker、Kubernetes、Python等领域相关技术干货,期待与您相遇!

    展开全文
  • Apache代理技术

    2019-02-26 11:11:00
    Apache代理技术 apache代理分为正向代理和反向代理。 正向代理是一个位于客户端和原始服务器之间的服务器, 客户端通过代理服务器访问外部的 web, 需要在客户端的浏览器中设置代理服务器。 反向代理正好相反,是代理...

     Apache代理技术
      apache代理分为正向代理和反向代理。 正向代理是一个
    位于客户端和原始服务器之间的服务器, 客户端通过代理服
    务器访问外部的 web, 需要在客户端的浏览器中设置代理服
    务器。 反向代理正好相反,是代理服务器来接受 Internet上的
    连接请求,然后将请求转发给内部网络上的服务器,并将从服
    务器上得到的结果返回给 Internet上请求连接的客户端,此时
    代理服务器对外就表现为一个服务器。
      利用反向代理服务器,浏览器访问的是代理服务器,通过
    代理服务器才访问到网站,浏览器无法得到网站的真实 IP 地
    址, 反向代理服务器使内部服务器对外部网络来说完全不可
    见,从而保证了内部网络服务器的安全。
      对于客户端而言它就像是原始服务器, 客户端向反向代
    理发送普通请求,反向代理将判断向何处(原始服务器)转交
    请求,并将获得的内容返回给客户端,客户端不需要进行任何
    特别的设置。

    转载于:https://www.cnblogs.com/songsongblue/p/10436041.html

    展开全文
  • Java代理技术

    2018-02-28 23:05:04
    前言 Java代理分为静态代理与动态代理(jdk、cglib、javaassit等),它是整个java...代理模式是常用的java设计模式之一,它的理论依据就是java代理技术。 代理模式使用的场景很多,常见的有以下几种: 因安全...

    前言

    Java代理分为静态代理与动态代理(jdk、cglib、javaassit等),它是整个java技术中最为重要的技术之一。其中,动态代理更是在很多java框架中得到广泛地使用,比如spring aop,mybatis,hibernate等等。

    使用场景

    代理模式是常用的java设计模式之一,它的理论依据就是java代理技术。
    代理模式使用的场景很多,常见的有以下几种:

    • 因安全原因屏蔽客户端直接访问真实对象;
    • 在远程调用中使用代理类处理远程方法调用的技术细节(RMI);
    • 为提升性能,对真实对象进行封装,从而达到延迟加载的目的;
    • 为关键的业务类记录方法执行日志;
    • 为频繁访问的数据增加缓存功能;
    • 为系统中分散在各处的业务添加通用的逻辑。

    代理的实现方式

    静态代理

    代理类和目标类需要实现相同的接口,对静态代理类方法的调用都是通过委托给目标对象实现的。
    缺点:对不同的目标类,需要定义不同的静态代理类,会造成大量的样板式重复代码;目标接口新增方法,目标类与代理类都需要修改,增加了代码维护的复杂度。
    基于上述原因,通常都采用动态代理进行解决。

    /**
     * 静态代理
     * @author wxyh
     * @date 2018/02/28
     */
    public class StaticProxy implements HelloService {
    
        /**
         * 目标对象
         */
        private final HelloService target;
    
        public StaticProxy(HelloService target) {
            super();
            this.target = target;
        }
    
        @Override
        public void sayHello(String name) {
            System.out.println("Before execute StaticProxy.sayHello...");
            if (new Random().nextBoolean()) {
                // 控制对目标对象的访问
                target.sayHello(name);
                System.out.println("Say hello successfully!");
            } else {
                System.out.println(name + " absence. Say hello failed!");
            }
            System.out.println("After execute StaticProxy.sayHello...");
        }
    
    }

    JDK动态代理

    JDK自带的动态代理,不需要添加其他依赖,代理类和目标类实现同一个接口。
    缺点:代理类继承自Proxy类,所以只能代理实现了接口的类;代理类通过反射机制调用目标对象方法,性能有一定损耗。

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * JDK动态代理工厂
     * @author wxyh
     * @date 2018/02/28
     */
    public class JdkProxyFactory {
    
        /**
         * 获取代理对象
         * @param target 目标对象
         * @return 代理对象
         */
        @SuppressWarnings("unchecked")
        public static <T> T getProxyObject(Object target) {
            return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(), new JdkDynamicProxy(target));
        }
    
        /**
         * JDK动态代理<br>
         * @author wxyh
         * @date 2018/02/28
         */
        public static class JdkDynamicProxy implements InvocationHandler {
    
            /**
             * 目标对象
             */
            private final Object target;
    
            public JdkDynamicProxy(Object target) {
                super();
                this.target = target;
            }
    
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String fullMethodName = method.getDeclaringClass().getName() + "." + method.getName();
                // 前置逻辑
                System.out.println("JdkDynamicProxy::Before execute " + fullMethodName);
                System.out.println("Jdk Proxy Object::" + proxy.getClass().getName());
                // 反射调用目标对象方法
                Object result = method.invoke(this.target, args);
                // 后置逻辑
                System.out.println("JdkDynamicProxy::After execute " + fullMethodName);
                return result;
            }
    
        }
    
    }

    CGLIB动态代理

    代理类对被代理类是否实现接口没有强制要求,适用范围更广,方法调用性能好。

    import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    /**
     * CGLIB动态代理工厂
     * @author wxyh
     * @date 2018/02/28
     */
    public class CglibProxyFactory {
    
        /**
         * 获取代理对象
         * @param target 目标对象
         * @return 代理对象
         */
        @SuppressWarnings("unchecked")
        public static <T> T getProxyObject(Object target) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(target.getClass());
            enhancer.setCallback(new CglibDynamicProxy(target));
            return (T) enhancer.create();
        }
    
        /**
         * CGLIB动态代理<br>
         * 动态生成的代理类为目标类的子类,在代理类中植入增强
         * @author wxyh
         * @date 2018/02/28
         */
        public static class CglibDynamicProxy implements MethodInterceptor {
    
            /**
             * 目标对象
             */
            @SuppressWarnings("unused")
            private final Object target;
    
            public CglibDynamicProxy(Object target) {
                super();
                this.target = target;
            }
    
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                String fullMethodName = method.getDeclaringClass().getName() + "." + method.getName();
                // 前置逻辑
                System.out.println("CglibDynamicProxy::Before execute " + fullMethodName);
                System.out.println("Cglib Proxy Object::" + obj.getClass().getName());
                // 调用代理对象方法
                Object result = proxy.invokeSuper(obj, args);
                // 后置逻辑
                System.out.println("CglibDynamicProxy::After execute " + fullMethodName);
                return result;
            }
    
        }
    
    }

    HelloService接口及其实现类

    /**
     * @author wxyh
     * @date 2018/02/28
     */
    public interface HelloService {
        void sayHello(String name);
    }
    /**
     * @author wxyh
     * @date 2018/02/28
     */
    public class HelloServiceImpl implements HelloService {
    
        @Override
        public void sayHello(String name) {
            System.out.println(String.format("Hello %s!", StringUtils.defaultIfBlank(name, "World")));
        }
    
    }
    /**
     * @author wxyh
     * @date 2018/02/28
     */
    public class HelloServiceImpl2 {
    
        public void sayHello(String name) {
            System.out.println(String.format("Hello %s!", StringUtils.defaultIfBlank(name, "World")));
        }
    
    }

    测试代码

    /**
     * @author wxyh
     * @date 2018/02/28
     */
    public class ProxyTest {
    
        /**
         * 测试静态代理
         */
        @Test
        public void testStaticProxy() {
            HelloService helloServcie = new StaticProxy(new HelloServiceImpl());
            helloServcie.sayHello("xyz");
        }
    
        /**
         * 测试JDK动态代理
         */
        @Test
        public void testJdkProxy() {
            long start = System.currentTimeMillis();
            // 目标对象实现HelloService接口
            HelloService helloServcie = JdkProxyFactory.getProxyObject(new HelloServiceImpl());
            System.out.println("Create jdkProxy took " + (System.currentTimeMillis() - start) + "ms.");
            helloServcie.sayHello("xyz");
        }
    
        /**
         * 测试CGLIB动态代理
         */
        @Test
        public void testCglibProxy() {
            long start = System.currentTimeMillis();
            // 目标对象实现HelloService接口
            HelloService helloServcie = CglibProxyFactory.getProxyObject(new HelloServiceImpl());
            System.out.println("Create cglibProxy took " + (System.currentTimeMillis() - start) + "ms.");
            helloServcie.sayHello("xyz");
    
            System.out.println();
    
            // 目标对象没有实现接口
            HelloServiceImpl2 helloServcie2 = CglibProxyFactory.getProxyObject(new HelloServiceImpl2());
            helloServcie2.sayHello("xyz");
        }
    
    }
    

    测试结果

    Create jdkProxy took 1ms.
    JdkDynamicProxy::Before execute com.wxyh.springbootproject.common.service.HelloService.sayHello
    Jdk Proxy Object::com.sun.proxy.$Proxy4
    Hello xyz!
    JdkDynamicProxy::After execute com.wxyh.springbootproject.common.service.HelloService.sayHello
    
    Before execute StaticProxy.sayHello...
    xyz absence. Say hello failed!
    After execute StaticProxy.sayHello...
    
    Create cglibProxy took 77ms.
    CglibDynamicProxy::Before execute com.wxyh.springbootproject.common.service.HelloServiceImpl.sayHello
    Cglib Proxy Object::com.wxyh.springbootproject.common.service.HelloServiceImpl$$EnhancerByCGLIB$$3b897022
    Hello xyz!
    CglibDynamicProxy::After execute com.wxyh.springbootproject.common.service.HelloServiceImpl.sayHello
    
    CglibDynamicProxy::Before execute com.wxyh.springbootproject.common.service.HelloServiceImpl2.sayHello
    Cglib Proxy Object::com.wxyh.springbootproject.common.service.HelloServiceImpl2$$EnhancerByCGLIB$$967091cc
    Hello xyz!
    CglibDynamicProxy::After execute com.wxyh.springbootproject.common.service.HelloServiceImpl2.sayHello

    从测试结果可知,JDK动态代理创建过程快,这是因为创建代理对象时,调用了Proxy$ProxyClassFactory.apply方法,该方法通过调用本地方法defineClass0创建的代理对象,故其性能要高于其他实现。但JDK动态代理类的函数调用是通过反射调用目标方法的,其性能不如CGLIB动态代理。

    展开全文
  • 代理

    2021-03-19 11:57:48
    常用的代理技术分为正向代理、反向代理和透明代理。 正向代理 一般情况下,如果没有特别说明,代理技术默认说的是正向代理技术。关于正向代理的概念如下: 正向代理是一个位于客户端【用户A】和原始服务器(origin ...

    代理技术如何实现

    一般实现代理技术的方式就是在服务器上安装代理服务软件,让其成为一个代理服务器,从而实现代理技术。
    常用的代理技术分为正向代理、反向代理和透明代理

    正向代理

    一般情况下,如果没有特别说明,代理技术默认说的是正向代理技术。关于正向代理的概念如下:

    正向代理是一个位于客户端【用户A】和原始服务器(origin server)【服务器B】之间的服务器【代理服务器Z】,为了从原始服务器取得内容,用户A向代理服务器Z发送一个请求并指定目标(服务器B),然后代理服务器Z向服务器B转交请求并将获得的内容返回给客户端。客户端需要设置正向代理服务器,当然前提是要知道正向代理服务器的IP地址,还有代理程序的端口,才能使用正向代理。如下图所示:
    在这里插入图片描述

    正向代理.png
    从上面的概念中,我们看出,文中所谓的正向代理就是代理服务器替代访问方【用户A】去访问目标服务器【服务器B】。很好的体现了正向代理的应用,其中之一就是科学上网,当然还有前端常用的抓包工具Whistle。

    Whistle其实就是将开发用的PC变为代理服务器,当移动端设备设置好代理用的PC的IP和代理服务端口号之后,移动端设备所有的请求和服务端响应的数据,都要经过Whistle代理服务,因此前端开发者们,可以在PC上观察接口的响应情况。

    反向代理

    反向代理正好与正向代理相反,对于客户端而言代理服务器就像是原始服务器,并且客户端不需要进行任何特别的设置。客户端向反向代理的命名空间(name-space)中的内容发送普通请求,接着反向代理将判断向何处(原始服务器)转交请求,并将获得的内容返回给客户端。
    在这里插入图片描述

    反向代理.png

    那反向代理的作用是什么呢?主要有以下两个方面:
    1、保护和隐藏原始服务器;
    2、负载均衡
    在这里插入图片描述

    负载均衡.png
    总结
    1、正向代理需要客户端进行配置(配置代理服务器的ip和端口),反向代理需要服务端进行配置;
    2、正向代理,对于原始服务器来说,不知道请求的真正用户是谁;
    3、反向代理,对于用户来说,不知道原始服务器到底隐藏在哪里。

    展开全文
  • Java的代理技术

    2020-06-21 16:26:15
    Java的代理技术Java代理静态代理动态代理JDK动态代理CGLIB动态代理 Java代理 Java代理分为静态代理和动态代理; 静态代理:由程序员创建或工具生成代理类的源码,再编译代理类,即代理类和委托类的关系再程序运行前...
  • 常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术
  • 动态代理技术

    2015-02-28 23:25:53
    1分析代理类的作用与原理及AOP概念 当我们已经开发好了一个类,这时我们需要为这个类添加日志,计数,事务管理 那我们什么...代理分为静态代理和动态代理 1. 代理分类 a) 静态代理:代理类的方法要和接口方式一致! b)
  • 常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术。 一、正向代理(Forward Proxy) 一般情况下,如果没有特别说明,...
  • 常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术。 一:正向代理(Forward Proxy) 一般情况下,如果没有特别说明...
  • 常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术。 一:正向代理(Forward Proxy) 一般情况下,如果没有特别说...
  • 图解正向代理、反向代理、透明代理 ...常用的代理技术分为正向代理、反向代理和透明代理。本文就是针对这三种代理来讲解一些基本原理和具体的适用范围,便于大家更深入理解代理服务技术。 一、正向代理(Fo

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 841
精华内容 336
关键字:

代理技术分为