精华内容
下载资源
问答
  • nginx做代理服务器的几种简单配置

    千次阅读 2018-11-24 17:04:00
    首先要知道nginx的代理相对于lvs不同是七层的代理,报文在流经PREROUTING时发现对方的目标IP是自己会将数据发往应用层,nginx的proxy模块会将数据解析然后以自己的ip地址为源地址发送给被代理的服务器。所以返回的...
        

    首先要知道nginx的代理相对于lvs不同是七层的代理,报文在流经PREROUTING时发现对方的目标IP是自己会将数据发往应用层,nginx的proxy模块会将数据解析然后以自己的ip地址为源地址发送给被代理的服务器。所以返回的响应数据也要流经nginx代理服务器。
    配置nginx服务能够进行代理很简单
    编辑配置文件

    nginx]# cat conf.d/proxy.conf 
    server {
            listen 80;
            server_name node1.lvqing.com;
            location / {
                    proxy_pass http://192.168.0.11;
                    }
    }
    

    这里也可以使用域名,这样就可以代理给一台服务器的不同虚拟主机


    13920922-c93df303564e1e88.png
    image.png

    看,一个简单的nginx代理就这样完成了,非常简单。

    注意:proxy_pass后面的路径不带url时,其会将location的url传递给后端主机;proxy_pass后面的路径是一个url时,其会将location的url替换为proxy_pass的
    如果location定义其uri时使用了正则表达式的模式,或在if语句或limt_execept中使用proxy_pass指令,则proxy_pass之后必须不能使用url; 用户请求时传递的url将直接附加代理到的服务器的之后

    nginx传递参数

    但是这样依赖有一个问题,如果再服务器上想要查看客户端的信息或者用来做会话缓存的标识是无法完成的,因为所有的客户端都是通过proxy代理过来的,我们所看到的链接的ip都是prox代理服务器的。这样我们就需要proxy传递给我们一些参数以便标识不同主机访问的
    proxy_set_header field value;
    设定发往后端主机的请求报文的请求首部的值;
    有一些内部的变量可以使用:

    • $remote_addr:代表了客户端的IP,可能是最后一个代理服务器的地址
    • proxy_add_x_forwarded_for ```
      再http服务器上设置日志的格式
      13920922-eda675db85e6380b.png
      image.png

    为了客户访问网站能有更好的体验,我们可以在proxy代理上做缓存,但如果缓存的内容太多放在磁盘上搜索起来费时费力,我们可以将用户的url做hash计算存放在内存中,数据分三级目录存放在磁盘上,
    缓存功能必须定义在http块中
    proxy_cache_path /var/nginx/cache levels=1:1:1 keys_zone=pcache:10m max_size=2g;
    然后我们需要在server中使用定义的缓存

    proxy_cache pcache;
    proxy_cache_key $request_uri;
    proxy_cache_methods GET HEAD;
    proxy_cache_vaild 200 302 10m;
    proxy_cache_vaild 404 1m;
    

    nginx的upstream模块

    既然可以做代理那么nginx也可以为后端的服务器做负载均衡,而且nginx做反向代理的upstream模块自带检测后端服务器是否可用的功能。这需要用到nginx的http的upstream模块,注意这个模块只适用于http协议,upstream引入的新上下文和server没关系只能被定义在http块中。
    在upstream的上下文中server是用来定义一个虚拟主机的

    编辑nginx.conf添加一个虚拟组

     upstream websrvs {
            server 192.168.0.11:80;
            server 192.168.0.12:80;
            }
    

    编辑虚拟主机文件

    server {
            listen 80;
            server_name node1.lvqing.com;
    
            location / {
                    root /var/nginx/www;
                    proxy_pass http://websrvs;
                    }
    }                         
    

    查看效果

    13920922-d62c5629ebd13e1a.png
    image.png

    在upstream中我们可以添加
    hash $request_uri;
    这就相当于lvs的sh算法,请求的uri相同就发往同一个服务器,可以提高缓存的命中率
    13920922-799eaa0586b3bfa7.png
    image.png

    consistent指的是一次性hash算法

    相对于upstream的七层代理nginx还提供了由ngx_stream_core_module模块提供的伪四层代理功能
    这里引入了新的stream上下文,所以stream不仅仅可以代理http还可以代理其他工作在四层以上的协议。
    只需要在配置文件中配置一个stream的上下文,其他的都不需要,当然还是需要监听在一个套接字上,因为nginx能做四层代理,本身是工作在第七层的。

    stream {
            server {
                    listen 22000;                                                                                                                  
                    proxy_pass 192.168.0.11:22;
                    }
            }
    

    可以看到ssh服务被代理到了11主机上。


    13920922-a0c2eae4f6540b86.png
    image.png
    展开全文
  • Shell判断字符串包含关系几种方法

    万次阅读 2017-05-02 17:46:25
    Shell判断字符串包含关系几种方法
       Shell中判断字符串包含关系的方法:
       1、通过grep来判断:
    
    str1="abcdefgh"
    str2="def"
    result=$(echo $str1 | grep "${str2}")
    if [[ "$result" != "" ]]
    then
        echo "包含"
    else
        echo "不包含"
    fi
       先打印长字符串,然后在长字符串中 grep 查找要搜索的字符串,用变量result记录结果,如果结果不为空,说明str1包含str2。如果结果为空,说明不包含。这个方法充分利用了grep 的特性,最为简洁。
       2、字符串运算符
    
    str1="abcdefgh"
    str2="def"
    if [[ $str1 =~ $str2 ]]
    then
        echo "包含"
    else
        echo "不包含"
    fi
       利用字符串运算符 =~ 直接判断str1是否包含str2。
       3、利用通配符
    
    str1="abcdefgh"
    str2="def"
    if [[ $str1 == *$str2* ]]
    then
        echo "包含"
    else
        echo "不包含"
    fi
       用通配符*号代理str1中非str2的部分,如果结果相等说明包含,反之不包含。
       4、利用case in 语句
    
    str1="abcdefgh"
    str2="def"
    case $str1 in 
        *"$str2"*) echo Enemy Spot ;;
        *) echo nope ;;
    esa
       5、利用替换
    
    str1="abcdefgh"
    str2="def"
    if [[ ${str1/${str2}//} == $str1 ]]
        then
           echo "不包含"
        else
          echo "包含"
    fi
    展开全文
  • 代理模式是常用的java设计模式,他的特征是代理类与委托类同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类...
    代理模式 
    代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。 
    按照代理的创建时期,代理类可以分为两种。 
    静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。 
    动态代理:在程序运行时,运用反射机制动态创建而成。 

     

    首先看一下静态代理: 
    1、Count.java 

    Java代码 
    1. package ustc.zyy
    2.   
    3. /** 
    4.  * 定义一个账户接口 
    5.  *  
    6.  * @author Administrator
    7. *zhang yin ye
    8. *zyyjiao@mail.ustc.edu.cn
    9.  *  
    10.  */  
    11. public interface Count {  
    12.     // 查看账户方法  
    13.     public void queryCount();  
    14.   
    15.     // 修改账户方法  
    16.     public void updateCount();  
    17.   
    18. }  


    2、CountImpl.java 

    Java代码 
    1. package ustc.zyy 

      /** 

       * 定义一个账户接口 

       

      * @author Administrator

      *zhang yin ye

      *zyyjiao@mail.ustc.edu.cn

       *  

       */ 

    2.   

    3.   
    4. /** 
    5.  * 委托类(包含业务逻辑) 
    6.  *  
    7.  * @author Administrator 
    8.  *  
    9.  */  
    10. public class CountImpl implements Count {  
    11.   
    12.     @Override  
    13.     public void queryCount() {  
    14.         System.out.println("查看账户方法...");  
    15.   
    16.     }  
    17.   
    18.     @Override  
    19.     public void updateCount() {  
    20.         System.out.println("修改账户方法...");  
    21.   
    22.     }  
    23.   
    24. }  
    25.    
    1. package ustc.zyy;
    2.   

    3.   
    4. /** 
    5.  * 这是一个代理类(增强CountImpl实现类) 
    6.  *  
    7.  * @author Administrator
    8. zyyjiao@mail.ustc.edu.cn
    9.  *  
    10.  */  
    11. public class CountProxy implements Count {  
    12.     private CountImpl countImpl;  
    13.   
    14.     /** 
    15.      * 覆盖默认构造器 
    16.      *  
    17.      * @param countImpl 
    18.      */  
    19.     public CountProxy(CountImpl countImpl) {  
    20.         this.countImpl = countImpl;  
    21.     }  
    22.   
    23.     @Override  
    24.     public void queryCount() {  
    25.         System.out.println("事务处理之前");  
    26.         // 调用委托类的方法;  
    27.         countImpl.queryCount();  
    28.         System.out.println("事务处理之后");  
    29.     }  
    30.   
    31.     @Override  
    32.     public void updateCount() {  
    33.         System.out.println("事务处理之前");  
    34.         // 调用委托类的方法;  
    35.         countImpl.updateCount();  
    36.         System.out.println("事务处理之后");  
    37.   
    38.     }  
    39.   
    40. }  

     

    3、TestCount.java 

    Java代码 
    1. package ustc.zyy;  
    2.   
    3. import net.battier.dao.impl.CountImpl;  
    4. import net.battier.dao.impl.CountProxy;  
    5.   
    6. /** 
    7.  *测试Count类 
    8.  *  
    9.  * @author Administrator 
    10.  *  zyyjiao@mail.ustc.edu.cn
    11.  */  
    12. public class TestCount {  
    13.     public static void main(String[] args) {  
    14.         CountImpl countImpl = new CountImpl();  
    15.         CountProxy countProxy = new CountProxy(countImpl);  
    16.         countProxy.updateCount();  
    17.         countProxy.queryCount();  
    18.   
    19.     }  
    20. }  

     

    观察代码可以发现每一个代理类只能为一个接口服务,这样一来程序开发中必然会产生过多的代理,而且,所有的代理操作除了调用的方法不一样之外,其他的操作都一样,则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能,那么此时就必须使用动态代理完成。 
    再来看一下动态代理: 
    JDK动态代理中包含一个类和一个接口: 
    InvocationHandler接口: 
    public interface InvocationHandler { 
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 

    参数说明: 
    Object proxy:指被代理的对象。 
    Method method:要调用的方法 
    Object[] args:方法调用时所需要的参数 

    可以将InvocationHandler接口的子类想象成一个代理的最终操作类,替换掉ProxySubject。 

    Proxy类: 
    Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态地生成实现类,此类提供了如下的操作方法: 
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
    InvocationHandler h) 
                                   throws IllegalArgumentException 
    参数说明: 
    ClassLoader loader:类加载器 
    Class<?>[] interfaces:得到全部的接口 
    InvocationHandler h:得到InvocationHandler接口的子类实例 

    Ps:类加载器 
    在Proxy类中的newProxyInstance()方法中需要一个ClassLoader类的实例,ClassLoader实际上对应的是类加载器,在Java中主要有一下三种类加载器; 
    Booststrap ClassLoader:此加载器采用C++编写,一般开发中是看不到的; 
    Extendsion ClassLoader:用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类; 
    AppClassLoader:(默认)加载classpath指定的类,是最常使用的是一种加载器。 

    动态代理 
    与静态代理类对照的是动态代理类,动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

    动态代理示例: 
    1、BookFacade.java 

    Java代码 
    1. package ustc.zyy;  
    2.   
    3. public interface BookFacade {  
    4.     public void addBook();  
    5. }  

     

     

    Java代码 
    1. package ustc.zyy; 
    2.   

    3.   
    4. public class BookFacadeImpl implements BookFacade {  
    5.   
    6.     @Override  
    7.     public void addBook() {  
    8.         System.out.println("增加图书方法。。。");  
    9.     }  
    10.   
    11. }  
    12.   
    1.   
    2. package ustc.zyy; 
    3.   
    4. import java.lang.reflect.InvocationHandler;  
    5. import java.lang.reflect.Method;  
    6. import java.lang.reflect.Proxy;  
    7.   
    8. /** 
    9.  * JDK动态代理代理类 
    10.  *  
    11.  * @author zhangyinye zyyjiao@mail.ustc.edu.cn
    12.  *  
    13.  */  
    14. public class BookFacadeProxy implements InvocationHandler {  
    15.     private Object target;  
    16.     /** 
    17.      * 绑定委托对象并返回一个代理类 
    18.      * @param target 
    19.      * @return 
    20.      */  
    21.     public Object bind(Object target) {  
    22.         this.target = target;  
    23.         //取得代理对象  
    24.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
    25.                 target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷,cglib弥补了这一缺陷)  
    26.     }  
    27.   
    28.     @Override  
    29.     /** 
    30.      * 调用方法 
    31.      */  
    32.     public Object invoke(Object proxy, Method method, Object[] args)  
    33.             throws Throwable {  
    34.         Object result=null;  
    35.         System.out.println("事物开始");  
    36.         //执行方法  
    37.         result=method.invoke(target, args);  
    38.         System.out.println("事物结束");  
    39.         return result;  
    40.     }  
    41.   
    42. }  

     

    3、TestProxy.java 

    Java代码 
    1. package ustc.zyy;  
    2.   
    3.   
    4. public class TestProxy {  
    5.   
    6.     public static void main(String[] args) {  
    7.         BookFacadeProxy proxy = new BookFacadeProxy();  
    8.         BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
    9.         bookProxy.addBook();  
    10.     }  
    11.   
    12. }  

     

    但是,JDK的动态代理依靠接口实现,如果有些类并没有实现接口,则不能使用JDK代理,这就要使用cglib动态代理了。 

    Cglib动态代理 
    JDK的动态代理机制只能代理实现了接口的类,而不能实现接口的类就不能实现JDK的动态代理,cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。 
    示例 
    1、BookFacadeCglib.java 

    Java代码 
    1. package ustc.zyy;  
    2.   
    3. public interface BookFacade {  
    4.     public void addBook();  
    5. }  

     

    2、BookCadeImpl1.java 

    Java代码 
    1. package ustc.zyy;  
    2.   
    3. /** 
    4.  * 这个是没有实现接口的实现类 
    5.  *  
    6.  * @author zyyjiao@mial.ustc.edu.cn
    7.  *  
    8.  */  
    9. public class BookFacadeImpl1 {  
    10.     public void addBook() {  
    11.         System.out.println("增加图书的普通方法...");  
    12.     }  
    13. }  


    3、BookFacadeProxy.java 

    Java代码 
    1. package ustc.zyy; 
    2.   
    3. import java.lang.reflect.Method;  
    4.   
    5. import net.sf.cglib.proxy.Enhancer;  
    6. import net.sf.cglib.proxy.MethodInterceptor;  
    7. import net.sf.cglib.proxy.MethodProxy;  
    8.   
    9. /** 
    10.  * 使用cglib动态代理 
    11.  *  
    12.  * @author zyyjiao@mail.ustc.edu.cn
    13.  *  
    14.  */  
    15. public class BookFacadeCglib implements MethodInterceptor {  
    16.     private Object target;  
    17.   
    18.     /** 
    19.      * 创建代理对象 
    20.      *  
    21.      * @param target 
    22.      * @return 
    23.      */  
    24.     public Object getInstance(Object target) {  
    25.         this.target = target;  
    26.         Enhancer enhancer = new Enhancer();  
    27.         enhancer.setSuperclass(this.target.getClass());  
    28.         // 回调方法  
    29.         enhancer.setCallback(this);  
    30.         // 创建代理对象  
    31.         return enhancer.create();  
    32.     }  
    33.   
    34.     @Override  
    35.     // 回调方法  
    36.     public Object intercept(Object obj, Method method, Object[] args,  
    37.             MethodProxy proxy) throws Throwable {  
    38.         System.out.println("事物开始");  
    39.         proxy.invokeSuper(obj, args);  
    40.         System.out.println("事物结束");  
    41.         return null;  
    42.   
    43.   
    44.     }  
    45.   
    46. }  


    4、TestCglib.java 

    Java代码 
    1. package ustc.zyy;  
    2.   
    3.   
    4. public class TestCglib {  
    5.       
    6.     public static void main(String[] args) {  
    7.         BookFacadeCglib cglib=new BookFacadeCglib();  
    8.         BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
    9.         bookCglib.addBook();  
    10.     }  

    展开全文
  • 轻松学,Java 中的代理模式及动态代理

    万次阅读 多人点赞 2017-06-29 22:08:55
    天我写了《秒懂,Java 注解 (Annotation)你可以这样学》,因为注解其实算反射技术中的一部分,然后我想了一下,反射技术中还有个常见的概念就是动态代理,于是索性再写一篇关于动态代理的博文好了。...

    前几天我写了《秒懂,Java 注解 (Annotation)你可以这样学》,因为注解其实算反射技术中的一部分,然后我想了一下,反射技术中还有个常见的概念就是动态代理,于是索性再写一篇关于动态代理的博文好了。

    我们先来分析代理这个词。

    代理

    代理是英文 Proxy 翻译过来的。我们在生活中见到过的代理,大概最常见的就是朋友圈中卖面膜的同学了。

    她们从厂家拿货,然后在朋友圈中宣传,然后卖给熟人。

    这里写图片描述

    按理说,顾客可以直接从厂家购买产品,但是现实生活中,很少有这样的销售模式。一般都是厂家委托给代理商进行销售,顾客跟代理商打交道,而不直接与产品实际生产者进行关联。

    所以,代理就有一种中间人的味道。

    接下来,我们说说软件中的代理模式。

    代理模式

    代理模式是面向对象编程中比较常见的设计模式。
    这里写图片描述

    这是常见代理模式常见的 UML 示意图。

    需要注意的有下面几点:

    1. 用户只关心接口功能,而不在乎谁提供了功能。上图中接口是 Subject。
    2. 接口真正实现者是上图的 RealSubject,但是它不与用户直接接触,而是通过代理。
    3. 代理就是上图中的 Proxy,由于它实现了 Subject 接口,所以它能够直接与用户接触。
    4. 用户调用 Proxy 的时候,Proxy 内部调用了 RealSubject。所以,Proxy 是中介者,它可以增强 RealSubject 操作。

    如果难于理解的话,我用事例说明好了。值得注意的是,代理可以分为静态代理和动态代理两种。先从静态代理讲起。

    静态代理

    我们平常去电影院看电影的时候,在电影开始的阶段是不是经常会放广告呢?

    电影是电影公司委托给影院进行播放的,但是影院可以在播放电影的时候,产生一些自己的经济收益,比如卖爆米花、可乐等,然后在影片开始结束时播放一些广告。

    现在用代码来进行模拟。

    首先得有一个接口,通用的接口是代理模式实现的基础。这个接口我们命名为 Movie,代表电影播放的能力。

    
    package com.frank.test;
    
    public interface Movie {
    	void play();
    }
    
    

    然后,我们要有一个真正的实现这个 Movie 接口的类,和一个只是实现接口的代理类。

    package com.frank.test;
    
    public class RealMovie implements Movie {
    
    	@Override
    	public void play() {
    		// TODO Auto-generated method stub
    		System.out.println("您正在观看电影 《肖申克的救赎》");
    	}
    
    }
    

    这个表示真正的影片。它实现了 Movie 接口,play() 方法调用时,影片就开始播放。那么 Proxy 代理呢?

    package com.frank.test;
    
    public class Cinema implements Movie {
    	
    	RealMovie movie;
    	
    	public Cinema(RealMovie movie) {
    		super();
    		this.movie = movie;
    	}
    
    
    	@Override
    	public void play() {
    		
    		guanggao(true);
    		
    		movie.play();
    		
    		guanggao(false);
    	}
    	
    	public void guanggao(boolean isStart){
    		if ( isStart ) {
    			System.out.println("电影马上开始了,爆米花、可乐、口香糖9.8折,快来买啊!");
    		} else {
    			System.out.println("电影马上结束了,爆米花、可乐、口香糖9.8折,买回家吃吧!");
    		}
    	}
    
    }
    
    

    Cinema 就是 Proxy 代理对象,它有一个 play() 方法。不过调用 play() 方法时,它进行了一些相关利益的处理,那就是广告。现在,我们编写测试代码。

    package com.frank.test;
    
    public class ProxyTest {
    
    	public static void main(String[] args) {
    		
    		RealMovie realmovie = new RealMovie();
    		
    		Movie movie = new Cinema(realmovie);
    		
    		movie.play();
    
    	}
    
    }
    
    

    然后观察结果:

    电影马上开始了,爆米花、可乐、口香糖9.8折,快来买啊!
    您正在观看电影 《肖申克的救赎》
    电影马上结束了,爆米花、可乐、口香糖9.8折,买回家吃吧!
    
    

    现在可以看到,代理模式可以在不修改被代理对象的基础上,通过扩展代理类,进行一些功能的附加与增强。值得注意的是,代理类和被代理类应该共同实现一个接口,或者是共同继承某个类。

    上面介绍的是静态代理的内容,为什么叫做静态呢?因为它的类型是事先预定好的,比如上面代码中的 Cinema 这个类。下面要介绍的内容就是动态代理。

    动态代理

    既然是代理,那么它与静态代理的功能与目的是没有区别的,唯一有区别的就是动态与静态的差别。

    那么在动态代理的中这个动态体现在什么地方?

    上一节代码中 Cinema 类是代理,我们需要手动编写代码让 Cinema 实现 Movie 接口,而在动态代理中,我们可以让程序在运行的时候自动在内存中创建一个实现 Movie 接口的代理,而不需要去定义 Cinema 这个类。这就是它被称为动态的原因。

    也许概念比较抽象。现在实例说明一下情况。

    假设有一个大商场,商场有很多的柜台,有一个柜台卖茅台酒。我们进行代码的模拟。

    package com.frank.test;
    
    public interface SellWine {
    	
    	 void mainJiu();
    
    }
    

    SellWine 是一个接口,你可以理解它为卖酒的许可证。

    package com.frank.test;
    
    public class MaotaiJiu implements SellWine {
    
    	@Override
    	public void mainJiu() {
    		// TODO Auto-generated method stub
    		System.out.println("我卖得是茅台酒。");
    
    	}
    
    }
    
    

    然后创建一个类 MaotaiJiu,对的,就是茅台酒的意思。

    我们还需要一个柜台来卖酒:

    package com.frank.test;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    
    public class GuitaiA implements InvocationHandler {
    	
    	private Object pingpai;
    	
    	
    	public GuitaiA(Object pingpai) {
    		this.pingpai = pingpai;
    	}
    
    
    
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		// TODO Auto-generated method stub
    		System.out.println("销售开始  柜台是: "+this.getClass().getSimpleName());
    		method.invoke(pingpai, args);
    		System.out.println("销售结束");
    		return null;
    	}
    
    }
    
    

    GuitaiA 实现了 InvocationHandler 这个类,这个类是什么意思呢?大家不要慌张,待会我会解释。

    然后,我们就可以卖酒了。

    package com.frank.test;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		MaotaiJiu maotaijiu = new MaotaiJiu();
    		
    		
    		InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
    
    		
    		SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao1);
    	
    		dynamicProxy.mainJiu();
    			
    	}
    
    }
    
    
    

    这里,我们又接触到了一个新的概念,没有关系,先别管,先看结果。

    销售开始  柜台是: GuitaiA
    我卖得是茅台酒。
    销售结束
    
    

    看到没有,我并没有像静态代理那样为 SellWine 接口实现一个代理类,但最终它仍然实现了相同的功能,这其中的差别,就是之前讨论的动态代理所谓“动态”的原因。

    动态代理语法

    放轻松,下面我们开始讲解语法,语法非常简单。

    动态代码涉及了一个非常重要的类 Proxy。正是通过 Proxy 的静态方法 newProxyInstance 才会动态创建代理。

    Proxy

    public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
    
    

    下面讲解它的 3 个参数意义。

    • loader 自然是类加载器
    • interfaces 代码要用来代理的接口
    • h 一个 InvocationHandler 对象

    初学者应该对于 InvocationHandler 很陌生,我马上就讲到这一块。

    InvocationHandler

    InvocationHandler 是一个接口,官方文档解释说,每个代理的实例都有一个与之关联的 InvocationHandler 实现类,如果代理的方法被调用,那么代理便会通知和转发给内部的 InvocationHandler 实现类,由它决定处理。

    public interface InvocationHandler {
    
        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
    }
    
    

    InvocationHandler 内部只是一个 invoke() 方法,正是这个方法决定了怎么样处理代理传递过来的方法调用。

    • proxy 代理对象
    • method 代理对象调用的方法
    • args 调用的方法中的参数

    因为,Proxy 动态产生的代理会调用 InvocationHandler 实现类,所以 InvocationHandler 是实际执行者。

    public class GuitaiA implements InvocationHandler {
    	
    	private Object pingpai;
    	
    	
    	public GuitaiA(Object pingpai) {
    		this.pingpai = pingpai;
    	}
    
    
    
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		// TODO Auto-generated method stub
    		System.out.println("销售开始  柜台是: "+this.getClass().getSimpleName());
    		method.invoke(pingpai, args);
    		System.out.println("销售结束");
    		return null;
    	}
    
    }
    
    

    GuitaiA 就是实际上卖酒的地方。

    现在,我们加大难度,我们不仅要卖茅台酒,还想卖五粮液

    package com.frank.test;
    
    public class Wuliangye implements SellWine {
    
    	@Override
    	public void mainJiu() {
    		// TODO Auto-generated method stub
    		System.out.println("我卖得是五粮液。");
    
    	}
    
    }
    
    

    Wuliangye 这个类也实现了 SellWine 这个接口,说明它也拥有卖酒的许可证,同样把它放到 GuitaiA 上售卖。

    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		MaotaiJiu maotaijiu = new MaotaiJiu();
    		
    		Wuliangye wu = new Wuliangye();
    		
    		InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
    		InvocationHandler jingxiao2 = new GuitaiA(wu);
    		
    		SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao1);
    		SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao2);
    		
    		dynamicProxy.mainJiu();
    		
    		dynamicProxy1.mainJiu();
    		
    	}
    
    }
    
    

    我们来看结果:

    销售开始  柜台是: GuitaiA
    我卖得是茅台酒。
    销售结束
    销售开始  柜台是: GuitaiA
    我卖得是五粮液。
    销售结束
    
    

    有人会问,dynamicProxy 和 dynamicProxy1 什么区别没有?他们都是动态产生的代理,都是售货员,都拥有卖酒的技术证书。

    我现在扩大商场的经营,除了卖酒之外,还要卖烟。

    首先,同样要创建一个接口,作为卖烟的许可证。

    package com.frank.test;
    
    public interface SellCigarette {
    	void sell();
    }
    
    

    然后,卖什么烟呢?我是湖南人,那就芙蓉王好了。

    public class Furongwang implements SellCigarette {
    
    	@Override
    	public void sell() {
    		// TODO Auto-generated method stub
    		System.out.println("售卖的是正宗的芙蓉王,可以扫描条形码查证。");
    	}
    
    }
    
    

    然后再次测试验证:

    package com.frank.test;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		MaotaiJiu maotaijiu = new MaotaiJiu();
    		
    		Wuliangye wu = new Wuliangye();
    		
    		Furongwang fu = new Furongwang();
    		
    		InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
    		InvocationHandler jingxiao2 = new GuitaiA(wu);
    		
    		InvocationHandler jingxiao3 = new GuitaiA(fu);
    		
    		SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao1);
    		SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao2);
    		
    		dynamicProxy.mainJiu();
    		
    		dynamicProxy1.mainJiu();
    		
    		SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(Furongwang.class.getClassLoader(),
    				Furongwang.class.getInterfaces(), jingxiao3);
    		
    		dynamicProxy3.sell();
    		
    	}
    
    }
    
    

    然后,查看结果:

    销售开始  柜台是: GuitaiA
    我卖得是茅台酒。
    销售结束
    销售开始  柜台是: GuitaiA
    我卖得是五粮液。
    销售结束
    销售开始  柜台是: GuitaiA
    售卖的是正宗的芙蓉王,可以扫描条形码查证。
    销售结束
    
    
    

    结果符合预期。大家仔细观察一下代码,同样是通过 Proxy.newProxyInstance() 方法,却产生了 SellWine 和 SellCigarette 两种接口的实现类代理,这就是动态代理的魔力。

    动态代理的秘密

    一定有同学对于为什么 Proxy 能够动态产生不同接口类型的代理感兴趣,我的猜测是肯定通过传入进去的接口然后通过反射动态生成了一个接口实例。
    比如 SellWine 是一个接口,那么 Proxy.newProxyInstance() 内部肯定会有

    
    new SellWine();
    

    这样相同作用的代码,不过它是通过反射机制创建的。那么事实是不是这样子呢?直接查看它们的源码好了。需要说明的是,我当前查看的源码是 1.8 版本。

    public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        {
            Objects.requireNonNull(h);
    
            final Class<?>[] intfs = interfaces.clone();
    
    
            /*
             * Look up or generate the designated proxy class.
             */
            Class<?> cl = getProxyClass0(loader, intfs);
    
            /*
             * Invoke its constructor with the designated invocation handler.
             */
            try {
    
    
                final Constructor<?> cons = cl.getConstructor(constructorParams);
                final InvocationHandler ih = h;
                if (!Modifier.isPublic(cl.getModifiers())) {
                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
                        public Void run() {
                            cons.setAccessible(true);
                            return null;
                        }
                    });
                }
    
                return cons.newInstance(new Object[]{h});
    
            } catch (IllegalAccessException|InstantiationException e) {
                throw new InternalError(e.toString(), e);
            } catch (InvocationTargetException e) {
                Throwable t = e.getCause();
                if (t instanceof RuntimeException) {
                    throw (RuntimeException) t;
                } else {
                    throw new InternalError(t.toString(), t);
                }
            } catch (NoSuchMethodException e) {
                throw new InternalError(e.toString(), e);
            }
        }
    
    
    

    newProxyInstance 的确创建了一个实例,它是通过 cl 这个 Class 文件的构造方法反射生成。cl 由 getProxyClass0() 方法获取。

    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
    
        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }
    
    

    直接通过缓存获取,如果获取不到,注释说会通过 ProxyClassFactory 生成。

    /**
         * A factory function that generates, defines and returns the proxy class given
         * the ClassLoader and array of interfaces.
         */
        private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>
        {
            // Proxy class 的前缀是 “$Proxy”,
            private static final String proxyClassNamePrefix = "$Proxy";
    
            // next number to use for generation of unique proxy class names
            private static final AtomicLong nextUniqueNumber = new AtomicLong();
    
            @Override
            public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    
                Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
                for (Class<?> intf : interfaces) {
                    /*
                     * Verify that the class loader resolves the name of this
                     * interface to the same Class object.
                     */
                    Class<?> interfaceClass = null;
                    try {
                        interfaceClass = Class.forName(intf.getName(), false, loader);
                    } catch (ClassNotFoundException e) {
                    }
                    if (interfaceClass != intf) {
                        throw new IllegalArgumentException(
                            intf + " is not visible from class loader");
                    }
                    /*
                     * Verify that the Class object actually represents an
                     * interface.
                     */
                    if (!interfaceClass.isInterface()) {
                        throw new IllegalArgumentException(
                            interfaceClass.getName() + " is not an interface");
                    }
                    /*
                     * Verify that this interface is not a duplicate.
                     */
                    if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                        throw new IllegalArgumentException(
                            "repeated interface: " + interfaceClass.getName());
                    }
                }
    
                String proxyPkg = null;     // package to define proxy class in
                int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
    
                /*
                 * Record the package of a non-public proxy interface so that the
                 * proxy class will be defined in the same package.  Verify that
                 * all non-public proxy interfaces are in the same package.
                 */
                for (Class<?> intf : interfaces) {
                    int flags = intf.getModifiers();
                    if (!Modifier.isPublic(flags)) {
                        accessFlags = Modifier.FINAL;
                        String name = intf.getName();
                        int n = name.lastIndexOf('.');
                        String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                        if (proxyPkg == null) {
                            proxyPkg = pkg;
                        } else if (!pkg.equals(proxyPkg)) {
                            throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                        }
                    }
                }
    
                if (proxyPkg == null) {
                    // if no non-public proxy interfaces, use com.sun.proxy package
                    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
                }
    
                /*
                 * Choose a name for the proxy class to generate.
                 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
    
                /*
                 * Generate the specified proxy class.
                 */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
                try {
                    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    /*
                     * A ClassFormatError here means that (barring bugs in the
                     * proxy class generation code) there was some other
                     * invalid aspect of the arguments supplied to the proxy
                     * class creation (such as virtual machine limitations
                     * exceeded).
                     */
                    throw new IllegalArgumentException(e.toString());
                }
            }
        }
    
    
    

    这个类的注释说,通过指定的 ClassLoader 和 接口数组 用工厂方法生成 proxy class。 然后这个 proxy class 的名字是:

    
    // Proxy class 的前缀是 “$Proxy”,
    private static final String proxyClassNamePrefix = "$Proxy";
    
    long num = nextUniqueNumber.getAndIncrement();
    
    String proxyName = proxyPkg + proxyClassNamePrefix + num;
    
    

    所以,动态生成的代理类名称是包名+$Proxy+id序号

    生成的过程,核心代码如下:

    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
    
             
    return defineClass0(loader, proxyName,
                        proxyClassFile, 0, proxyClassFile.length);
    
    

    这两个方法,我没有继续追踪下去,defineClass0() 甚至是一个 native 方法。我们只要知道,动态创建代理这回事就好了。

    现在我们还需要做一些验证,我要检测一下动态生成的代理类的名字是不是包名+$Proxy+id序号

    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		MaotaiJiu maotaijiu = new MaotaiJiu();
    		
    		Wuliangye wu = new Wuliangye();
    		
    		Furongwang fu = new Furongwang();
    		
    		InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
    		InvocationHandler jingxiao2 = new GuitaiA(wu);
    		
    		InvocationHandler jingxiao3 = new GuitaiA(fu);
    		
    		SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao1);
    		SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
    				MaotaiJiu.class.getInterfaces(), jingxiao2);
    		
    		dynamicProxy.mainJiu();
    		
    		dynamicProxy1.mainJiu();
    		
    		SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(Furongwang.class.getClassLoader(),
    				Furongwang.class.getInterfaces(), jingxiao3);
    		
    		dynamicProxy3.sell();
    		
    		System.out.println("dynamicProxy class name:"+dynamicProxy.getClass().getName());
    		System.out.println("dynamicProxy1 class name:"+dynamicProxy1.getClass().getName());
    		System.out.println("dynamicProxy3 class name:"+dynamicProxy3.getClass().getName());
    		
    	}
    
    }
    
    

    结果如下:

    销售开始  柜台是: GuitaiA
    我卖得是茅台酒。
    销售结束
    销售开始  柜台是: GuitaiA
    我卖得是五粮液。
    销售结束
    销售开始  柜台是: GuitaiA
    售卖的是正宗的芙蓉王,可以扫描条形码查证。
    销售结束
    
    dynamicProxy class name:com.sun.proxy.$Proxy0
    dynamicProxy1 class name:com.sun.proxy.$Proxy0
    dynamicProxy3 class name:com.sun.proxy.$Proxy1
    
    

    SellWine 接口的代理类名是:com.sun.proxy.$Proxy0
    SellCigarette 接口的代理类名是:com.sun.proxy.$Proxy1

    这说明动态生成的 proxy class 与 Proxy 这个类同一个包。

    下面用一张图让大家记住动态代理涉及到的角色。
    这里写图片描述
    红框中 $Proxy0就是通过 Proxy 动态生成的。
    $Proxy0实现了要代理的接口。
    $Proxy0通过调用 InvocationHandler来执行任务。

    代理的作用

    可能有同学会问,已经学习了代理的知识,但是,它们有什么用呢?

    主要作用,还是在不修改被代理对象的源码上,进行功能的增强。

    这在 AOP 面向切面编程领域经常见。

    在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

    主要功能
    日志记录,性能统计,安全控制,事务处理,异常处理等等。

    上面的引用是百度百科对于 AOP 的解释,至于,如何通过代理来进行日志记录功能、性能统计等等,这个大家可以参考 AOP 的相关源码,然后仔细琢磨。

    同注解一样,很多同学可能会有疑惑,我什么时候用代理呢?

    这取决于你自己想干什么。你已经学会了语法了,其他的看业务需求。对于实现日志记录功能的框架来说,正合适。

    至此,静态代理和动态代理者讲完了。

    总结

    1. 代理分为静态代理和动态代理两种。
    2. 静态代理,代理类需要自己编写代码写成。
    3. 动态代理,代理类通过 Proxy.newInstance() 方法生成。
    4. 不管是静态代理还是动态代理,代理与被代理者都要实现两样接口,它们的实质是面向接口编程。
    5. 静态代理和动态代理的区别是在于要不要开发者自己定义 Proxy 类。
    6. 动态代理通过 Proxy 动态生成 proxy class,但是它也指定了一个 InvocationHandler 的实现类。
    7. 代理模式本质上的目的是为了增强现有代码的功能。

    读者们都在下面的二维码所示的免费的知识星球问我问题:
    在这里插入图片描述

    展开全文
  • 代理模式的使用总结

    万次阅读 多人点赞 2020-04-20 14:14:37
    一、代理模式 二、静态代理 (一)静态代理 (二)静态代理简单实现 三、动态代理 (一)动态代理 (二)动态代理简单实现 四、动态代理原理分析 五、InvocationHandler接口和Proxy类详解 六、JDK动态代理...
  • 国内App推广N种方法,总有几种适合你

    千次阅读 2016-11-04 17:24:14
    国内App推广N种方法,总有几种适合你 移动互联网App推广的十大难题
  • Android Hook Activity 的几种姿势

    万次阅读 热门讨论 2018-08-06 19:35:28
    这篇博客已 API 27 的源码为基础分析 前言 在上一篇文章中,我们介绍了 Hook 的要点 Hook 的选择点:静态变量和...选择合适的代理方式,如果是接口可以用动态代理。 偷梁换柱——用代理对象替换原始对象。 And...
  • 几种常用的设计模式介绍

    万次阅读 多人点赞 2013-11-16 18:17:27
    几种常用的设计模式介绍 1.  设计模式的起源 最早提出“设计模式”概念的是建筑设计大师亚力山大Alexander。在1970年他的《建筑的永恒之道》里描述了投计模式的发现,因为它已经存在了千百年之久,而现代才被...
  • 动态代理的两方式以及区别

    万次阅读 多人点赞 2018-09-19 12:37:09
    动态代理的两方式,以及区别。 JDK动态代理:利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。 CGlib动态代理:利用ASM(开源的Java字节码编辑库,操作字节码)开源包,将...
  • 秒懂Java代理与动态代理模式

    万次阅读 多人点赞 2018-06-30 17:08:23
    版权申明】非商业目的可自由转载 博文地址: 出自:shusheng007 概述 什么是代理模式?解决什么问题(即为什么需要)?什么是静态代理?... 定义:为其他对象提供一种代理以控制对这个对象的访问 ...
  • 动态代理的两实现方式

    千次阅读 2018-12-24 11:05:04
    在java web中,很多的技术...在java中,动态代理技术:原生JDK,CGLIB,Javassist,ASM。其中,Spring常用JDK和CGLIB,而Mybatis中还使用了Javassist。本文只讲原生JDK,CGLIB这两最常用的方式。 1.原生JDK ...
  • 几种常见架构模式

    千次阅读 2015-12-01 00:19:10
    本节说的是几种常见架构模式。 AD: 6.2.2 几种常见架构模式 前文讲过,在实践中,人们总结出了一些常用的软件系统结构高层模式,以供应用系统设计时参考。这些模式包括:单服务两层/多层C/S;MVC结构
  • 解决Github速度太慢的几种方案

    千次阅读 2020-04-19 11:30:00
    Github速度太慢全网最全方案近日,我在Github上下载源码,真的鸡肋,慢的一匹,通过以下方式,让我下载Github速度飞快,因为刚好有代理,就用的第一种方式,而后面几种方式参考自网...
  • spring security控制权限的几种方法

    万次阅读 热门讨论 2012-02-11 10:38:37
     那么在Spring Security3的使用中,4方法:  一是全部利用配置文件,将用户、权限、资源(url)硬编码在xml文件中,已经实现过,并经过验证;  二是用户和权限用数据库存储,而资源(url)和权限的对应采用...
  • 常见的几种设计模式

    千次阅读 多人点赞 2019-02-28 09:45:27
    文章目录单例模式为什么会单例设计模式?应用spring中IOC解决的问题设计思想工厂模式简单工厂模式工厂方法模式观察者模式观察者模式的定义装饰模式模板方法定义:主要的作用:优点:缺点:应用场景:适配器模式...
  • JAVA中几种常用的RPC框架介绍

    万次阅读 多人点赞 2015-05-02 23:17:40
    RPC是远程过程调用的简称,广泛应用在大规模分布式应用中,作用是助于系统的垂直拆分,使系统更易拓展。Java中的RPC框架比较多,各特色,广泛使用的RMI、Hessian、Dubbo等。 1、RMI(远程方法调用) JAVA自带...
  • java中几种常用的设计模式

    万次阅读 2015-11-30 13:07:13
    java中常用的几种设计模式: 创建型:简单工厂模式(并不是23种设计模式之一)、工厂方法、抽象工厂模式、单例模式、生成器模式和原型模式结构型:适配器模式adapter、桥接模式bridge、组合器模式component、装饰...
  • 分布式通信的几种方式

    万次阅读 2016-09-20 09:19:01
    在分布式服务框架中,一个最基础的问题就是远程服务是怎么通讯的,特别是在Java领域中很多可实现远程通讯的技术,例如:RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等,这些名词之间到底是些什么关系呢,...
  • web服务器的几种缓存

    千次阅读 2016-01-05 11:11:02
    数据库缓存是指,当web应用的关系比较复杂,数据库中的表很多的时候,如果频繁进行 数据库查询,很容易导致数据库不堪重荷。为了提供查询的性能,将查询后的数据放到内存中进行缓存,下次查询时,直接从内存缓存直接...
  • 几种常见web 容器比较

    万次阅读 2018-10-25 22:32:08
    如与上面提到的JBoss集成起来开发EJB,与Cocoon(Apache的另外一个项目)集成起来开发基于Xml的应用,与OpenJMS集成起来开发JMS应用,除了我们提到的这几种,可以与Tomcat集成的软件还有很多。 二、Jboss JBoss是...
  • 网站安全之几种常见的网络攻击方式
  • 几种直播流媒体协议

    万次阅读 2017-06-01 21:30:34
    全部下载完毕后才能看到当中的内容,而是只需要经过秒钟或十秒的启动延时即可在用户计算机上利用 相应的播放器对压缩的视频或音频等流式媒体文件进行播放,剩余的部分将继续进行下载,直至播放完毕。 ...
  • 端口映射的几种方式

    千次阅读 2017-10-15 14:10:31
    端口映射动态和静态之分。端口映射是将一台主机的内网(LAN)IP地址映射成一个公网(WAN)IP地址,当用户访问提供映射端口主机的某个端口时,服务器将请求转移到本地局域网内部提供这种特定服务的主机;利用端口映射...
  • 简介几种负载均衡原理

    万次阅读 2017-05-03 22:51:13
    因为它的实际服务器的响应数据包可以不经过调度器而直接发往用户端啊,所以它与调度器的出口宽带没有关系,只能自身的有关系。而如果使用LVS-NAT,集群只能最大使用10Mbps的宽带。所以,越是响应数据包远远超过请求...
  • RabbitMQ的几种应用场景

    万次阅读 2014-12-15 19:14:56
    之前的篇文章介绍了一下RabbitMQ的概念以及环境的搭建和配置,了RabbitMQ环境就可以基于其实现一些特殊的任务场景了。RabbitMQ官方个很好的Tutorials基本覆盖了RabbitMQ的各中常见应用场景,先以代码加注释的...
  • Java代理和动态代理机制分析和应用

    千次阅读 2015-12-02 19:54:54
    本博文中项目代码已开源下载地址:GitHubJava代理和动态代理机制分析和应用概述代理是一常用的设计模式,其目的就是为其他...代理模式一般涉及到的角色4 主题接口:定义代理类和真实主题的公共对外方法,也是代理
  • 远程调用的几种方式

    万次阅读 2013-02-26 10:37:41
    在分布式服务框架中,一个最基础的问题就是远程服务是怎么通讯的,在Java领域中很多可实现远程通讯的技术,例如:RMI、MINA、ESB、 Burlap、Hessian、SOAP、EJB和JMS 等,这些名词之间到底是些什么关系呢,它们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 181,574
精华内容 72,629
关键字:

代理关系有哪几种