精华内容
下载资源
问答
  • npm离线安装?用代理吧

    千次阅读 2014-05-08 16:09:20
    答案很简单,用代理,把服务器上的npm,设置代理到可以访问外网的机子上(代理工具:ccproxy、fiddler等),即可解决问题! #npm config set proxy http://proxy.company.com:8080 #npm config set https


    服务器的机子,只能访问内网,不能访问外网。
    npm 安装命令都要有外网访问。难道一个接一个下载依赖包?


    答案很简单,用代理,把服务器上的npm,设置代理到可以访问外网的机子上(代理工具:ccproxy、fiddler等),即可解决问题!


    #npm config set proxy http://proxy.company.com:8080
    #npm config set https-proxy http://proxy.company.com:8080


    搞到以后,删除代理设置:
    #npm config delete proxy
    #npm config delete https-proxy

    其它详细参数:https://npmjs.org/doc/config.html


    附:直接给linux设置网络代理:
    #export http_proxy http://proxy.company.com:8080
    #export https_proxy http://proxy.company.com:8080

     

    前面日志中的例子需运行“npm install formidable”指令安装模块支持文件上传。

    如果浏览器有代理服务器,或者办公环境封杀了https,则需要设置npm环境变量。

    我看到的错误提示信息是这样:

    npm ERR! Error: failed to fetch from registry: formidable

    首先查看环境变量默认值(没准将来想设回去):

    >npm config get proxy
    null

    >npm config get registry
    https://registry.npmjs.org/

    然后设置新值:

    >npm config set registry http://registry.npmjs.vitecho.com

    >npm config set proxy=http://10.2.3.4:8080 (此处代理应与浏览器代理设置相同)

    如果继续安装看到下面的错误提示:

    npm ERR! Please try running this command again as root/Administrator.

    解决问题:“以管理员身份运行”cmd

    通过“npm list”指令可看到我已在办公环境成功安装formidable和express:

    C:Windowssystem32>npm list
    C:Windowssystem32
    ├─┬ express@2.5.9
    │ ├── connect@1.8.6
    │ ├── mime@1.2.4
    │ ├── mkdirp@0.3.0
    │ └── qs@0.4.2
    └── formidable@1.0.9

    进入用例路径,在启动服务器时看到下面的错误提示:

    Error: Cannot find module 'formidable'

    在同样的路径下再运行一次“npm install formidable”就行了(此处未究其原因)。

    本文出自 “iData” 博客,请务必保留此出处http://idata.blog.51cto.com/4581576/829802

    展开全文
  • 通过代码不难看出,代理类和被代理类实现了同一个接口,其实这个就是装饰设计模式。相对于继承,聚合的类结构无疑更方便管理和维护,但是它仍然有一个弊病:对于不同的功能,我仍然需要加类。例如:加权限控制功能...

    [ 需求分析 ]

    在我们实际开发中常常会遇到这样的问题:记录一个类的方法运行时间,以分析性能。一般我们的做法是先在类的开始记录一个开始时间,然后在类的结束记录一个结束时间,二者相减就可以获取我们想要的结果。但是很多时候这些类已经打了jar包,我们无法直接修改源码,这个时候我们应该怎么办呢?

    下文使用Tank的移动需要统计时间、记录日志来模拟需求场景,假定Moveable、Tank类无法修改。


    interface:Moveable

    public interface Moveable {
    	public void move();
    }


    realization:Tank

    public class Tank implements Moveable{
    	public void move() {
    		System.out.println("tank is moving");
    	}
    }

    [ 继承实现 ]

    ① 现在我们假设需要统计Tank移动的时间,通过实现Tank,并加入统计时间的代码即可做到

    import java.util.Random;
    /**
     * use to record tank move time
     * @author zhangjim
     */
    public class TankTimeProxy extends Tank {
    	public void move() {
    		try {
    			long start = System.currentTimeMillis();
    			super.move();
    			// make the tank move solwly
    			Thread.sleep(new Random().nextInt(1000)); 
    			long end = System.currentTimeMillis();
    			System.out.println("total spend time: " + (end - start) + "ms");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    ② 测试代码:

    /**
     * test client
     * @author zhangjim
     */
    public class Client {
    	public static void main(String[] args) {
    		Moveable m = new TankTimeProxy();
    		m.move();
    	}
    }
    ③ 分析:

    上述方法可以解决我们的问题,但如果现在需要增加需求:加入日志记录功能,那么我们就要再继承TankTimeProxy

    /**
     * use to record tank move logs
     * @author zhangjim
     */
    public class TankLogProxy extends TankTimeProxy{
    	public void move() {
    		System.out.println("tank start to move...");
    		super.move();
    		System.out.println("tank stop to move...");
    	}
    }

    这种实现方法存在一个很大的缺陷:很不灵活,如果后期还要加功能的话,就要不断的继承下去,父子关系过于臃肿,不利于维护。

    [ 静态代理 ]

    ① 接上文,现在我们使用静态代理实现上面的功能:

    重写TankTimeProxy:

    import java.util.Random;
    
    /**
     * use to record tank move time
     * @author zhangjim
     */
    public class TankTimeProxy implements Moveable {
    	private Moveable m;
    
    	public TankTimeProxy(Moveable m) {
    		this.m = m;
    	}
    
    	@Override
    	public void move() {
    		try {
    			long start = System.currentTimeMillis();
    			m.move();
    			Thread.sleep(new Random().nextInt(1000));
    			long end = System.currentTimeMillis();
    			System.out.println("total spend time: " + (end - start) + "ms");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }


    重写TankLogProxy:
    /**
     * use to record tank move logs
     * @author zhangjim
     */
    public class TankLogProxy implements Moveable{
    	private Moveable m;
    
    	public TankLogProxy(Moveable m) {
    		this.m = m;
    	}
    
    	@Override
    	public void move() {
    		System.out.println("tank start to move...");
    		m.move();
    		System.out.println("tank stop to move...");
    	}
    }

    ② 测试一下吧

    /**
     * test client
     * @author zhangjim
     */
    public class Client {
    	public static void main(String[] args) {
    		Moveable m = new TankLogProxy(new TankTimeProxy(new Tank()));
    		m.move();
    	}
    }

    ③ 分析:

    通过代码不难看出,代理类和被代理类实现了同一个接口,其实这个就是装饰设计模式。相对于继承,聚合的类结构无疑更方便管理和维护,但是它仍然有一个弊病:对于不同的功能,我仍然需要加类。例如:加权限控制功能需要TankAuthorityProxy,加事务控制功能需要TankTransactionProxy等等,能不能让计算机帮我们产生这些类?自己动手试试吧!


    [ 我的动态代理 ]

    ① 所谓的动态代理,就是说上文的TankTimeProxyTankLogProxy不需要我们手动创建了计算机会帮我们动态生成,也就是说这个代理类不是提前写好的,而是程序运行时动态生成的。


    我们写一个proxy类,它的作用就是帮我们产生代理类。

    主要实现思路:

    i  将所有方法代码拼接成字符串

    ii 将生成代理类的代码拼接成字符串(包含所有方法拼接成的字符串)

    iii 将此字符串写入文件中、并使用JavaComplier对它进行编译

    Ⅳ 将编译好的文件load进内存供我们使用,并返回代理实例。

    public class Proxy {
    	public static Object newProxyInstance(Class intefc, InvocationHandler handle) throws Exception {
    		String rt = "\r\t" ;
    		String methodStr = "" ;
    		
    		// first we should realize all the methods of the interface
    		Method[] methods = intefc.getMethods();
    		for (Method m : methods) {
    			methodStr +="public void "+m.getName()+"(){"+rt+
    						"    try{"+rt+
    						"        Method method = "+intefc.getName()+".class.getMethod(\""+m.getName()+"\");" + rt +
    						"        handle.invoke(this,method);" +rt+
    						"    }catch(Exception ex){}" +rt+
    						"}" ;
    						
    		}
    		String clazzStr =  "package com.zdp.dynamicProxy;"+rt+
    						   "import java.lang.reflect.Method;"+rt+
    						   "public class $Proxy1 implements "+intefc.getName()+"{"+rt+
    						   "    private com.zdp.dynamicProxy.InvocationHandler handle ;"+rt+
    						   "    public $Proxy1(InvocationHandler handle){"+rt+
    						   "        this.handle=handle;"+rt+
    						   "    }"+rt+
    						   "    @Override"+rt+
    						    methodStr +rt+
    						   "}";
    		
    		
    		// write to a java file 
    		File file = new File("D:/develop_environment/babasport/homework/src/com/zdp/dynamicProxy/$Proxy1.java") ;
    		FileWriter writer = null ;
    		try {
    			writer = new FileWriter(file);
    			writer.write(clazzStr) ;
    			writer.flush() ;
    		} catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			try {
    				if(writer !=null){
    					writer.close() ;
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		
    		//load the java file, and then create an instance 
    		URL[] urls = new URL[] {new URL("file:/" + "D:/develop_environment/babasport/homework/src/")};
    		URLClassLoader urlLoader = new URLClassLoader(urls);
    		Class c = urlLoader.loadClass("com.zdp.dynamicProxy.$Proxy1");
    		
    		//return the proxy instance
    		Constructor ctr = c.getConstructor(InvocationHandler.class);
    		Object proxyInstance = ctr.newInstance(handle);
    
    		return proxyInstance;
    	}
    }
    ② 因为要处理所有的业务,我们定义一个接口InvocationHandler

    public interface InvocationHandler {
    	public void invoke(Object o, Method m) ;  
    }

    ③ MyHandler是真正的处理类

    /**
     * use to record logs and time
     * @author zhangjim
     */
    public class MyHandler implements com.zdp.dynamicProxy.InvocationHandler {
    	private Object target;
    
    	public MyHandler(Object target) {
    		this.target = target;
    	}
    
    	public void invoke(Object obj, Method method) {
    		try {
    			System.out.println("tank start to move...");
    			long start = System.currentTimeMillis();
    			method.invoke(target);
    			Thread.sleep(new Random().nextInt(1000));
    			long end = System.currentTimeMillis();
    			System.out.println("total spend time: " + (end - start)  + "ms");
    			System.out.println("tank stop to move...");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    ④ Proxy类会帮我们动态创建一个类$Proxy1

    public class $Proxy1 implements com.zdp.dynamicProxy.Moveable {
    	private com.zdp.dynamicProxy.InvocationHandler handle;
    
    	public $Proxy1(InvocationHandler handle) {
    		this.handle = handle;
    	}
    
    	@Override
    	public void move() {
    		try {
    			Method method = com.zdp.dynamicProxy.Moveable.class.getMethod("move");
    			handle.invoke(this, method);
    		} catch (Exception ex) {
    		}
    	}
    }

    ⑤ 测试一下,看看效果怎么样

    /**
     * test client
     * @author zhangjim
     */
    public class Client {
    	public static void main(String[] args) throws Exception {
    		Moveable m = new Tank();
    		InvocationHandler handle = new MyHandler(m);
    		Moveable proxy = (Moveable) Proxy.newProxyInstance(Moveable.class, handle);
    		proxy.move();
    	}
    }

    ⑥ 简要总结:

    Proxy:动态创建代理类,通过调用处理器的处理方法来实现代理。

    InvocationHandler:实现对被代理对象的处理。


    [ 应用场景 ]

    ① 系统日志记录

    ② 权限控制(符合一定条件才执行某方法)

    ③ 事务控制(方法执行之前开启事务,方法执行之后提交或回滚事务)


    [ 特别感谢 ]

    这篇日志是对马士兵老师:《设计模式之动态代理》的一个总结,非常感谢马老师的辛勤工作。
    展开全文
  • 轻松学,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. 代理模式本质上的目的是为了增强现有代码的功能。

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

    展开全文
  • Nginx配置反向代理

    万次阅读 多人点赞 2019-07-14 14:05:31
    Nginx配置反向代理,什么是反向代理 反向代理服务器决定哪台服务器提供服务。返回代理服务器不提供服务器。只是请求的转发。

    更多Nginx教程可以点击下面的链接查看哦

    https://www.itqiankun.com/article/1564904492

    什么是反向代理

    反向代理服务器决定哪台服务器提供服务。返回代理服务器不提供服务器。只是请求的转发。
    正向代理如下
    在这里插入图片描述
    反向代理如下
    在这里插入图片描述

    Nginx实现反向代理的过程
    首先安装两个tomcat服务器,都放到nginx服务器里面,两个端口分别是8081和8082

    首先是下载tomcat,使用下面的命令

    wget http://mirror.bit.edu.cn/apache/tomcat/tomcat-7/v7.0.94/bin/apache-tomcat-7.0.94.tar.gz
    

    在这里插入图片描述
    然后是加载这个压缩包

    tar -xvf apache-tomcat-7.0.94.tar.gz
    

    在这里插入图片描述
    然后把apache-tomcat-7.0.94复制成两份,一份是tomcat8081,一份是tomcat8082,过程如下

    cp -r apache-tomcat-7.0.94 tomcat8081
    cp -r apache-tomcat-7.0.94 tomcat8082
    

    在这里插入图片描述
    然后通过Editplus远程连接修改tomcat8081里面的server.xml配置里面修改端口号,(怎么通过EditPlus连接linux,看着篇文章:https://blog.csdn.net/weixin_43689480/article/details/95867289,注意主要要修改三个端口号

    <Server port="8006" shutdown="SHUTDOWN">
    <Connector port="8081" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
    <Connector port="8010" protocol="AJP/1.3" redirectPort="8443" />
    

    然后通过Editplus远程连接修改tomcat8082里面的server.xml配置里面修改端口号(怎么通过EditPlus连接linux,看着篇文章:https://blog.csdn.net/weixin_43689480/article/details/95867289,注意主要要修改三个端口号

    <Server port="8007" shutdown="SHUTDOWN">
    <Connector port="8082" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
    <Connector port="8011" protocol="AJP/1.3" redirectPort="8443" />
    

    然后把tomact8081里面的webapps文件夹里面的ROOT文件夹里面的index.jsp变成下面这样,此时可以看到下面输入的内容是8081

    
    <!DOCTYPE html>
    <%@ page session="false" %>
    <%
    java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy");
    request.setAttribute("year", sdf.format(new java.util.Date()));
    request.setAttribute("tomcat7Url", "http://tomcat.apache.org/");
    request.setAttribute("tomcat7DocUrl", "/docs/");
    request.setAttribute("tomcat7ExamplesUrl", "/examples/");
    %>
    <html lang="en">
        <head>
            <title><%=request.getServletContext().getServerInfo() %></title>
            <link href="favicon.ico" rel="icon" type="image/x-icon" />
            <link href="favicon.ico" rel="shortcut icon" type="image/x-icon" />
            <link href="tomcat.css" rel="stylesheet" type="text/css" />
        </head>
    
        <body>
    		<h1>tomcat8081index.jsp<h1>
        </body>
    
    </html>
    

    然后把tomact8082里面的webapps文件夹里面的ROOT文件夹里面的index.jsp变成下面这样,此时可以看到下面输入的内容是8082

    
    <!DOCTYPE html>
    <%@ page session="false" %>
    <%
    java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy");
    request.setAttribute("year", sdf.format(new java.util.Date()));
    request.setAttribute("tomcat7Url", "http://tomcat.apache.org/");
    request.setAttribute("tomcat7DocUrl", "/docs/");
    request.setAttribute("tomcat7ExamplesUrl", "/examples/");
    %>
    <html lang="en">
        <head>
            <title><%=request.getServletContext().getServerInfo() %></title>
            <link href="favicon.ico" rel="icon" type="image/x-icon" />
            <link href="favicon.ico" rel="shortcut icon" type="image/x-icon" />
            <link href="tomcat.css" rel="stylesheet" type="text/css" />
        </head>
    
        <body>
    		<h1>tomcat8082index.jsp<h1>
        </body>
    
    </html>
    

    然后就是启动tomcat8081和tomcat8082,启动如下所示

    /root/tomcat8081/bin/startup.sh
    /root/tomcat8082/bin/startup.sh
    

    然后访问http://47.91.248.236:8081/ 路径结果如下,成功了

    在这里插入图片描述
    然后访问http://47.91.248.236:8082/ 路径结果如下,成功了
    在这里插入图片描述

    然后我们配置本地电脑里面的host文件变成下面这样

    这里我们借助ihost来操作
    在这里插入图片描述

    然后配置nginx服务器里面的conf文件夹里面的nginx.conf配置文件,配置完之后记得要重启nginx服务器

    此时当访问www.sina.com 的时候,就会访问host文件,然后就会去找47.91.248.236 这个ip对应的linux服务器,然后www.sina.com 默认的端口就是80,所以访问www.sina.com 的时候,就会找到下面的upstream tomcat1,然后下面的upstream tomcat1就会去找server 47.91.248.236:8081,就会找到8081端口的tomcat服务器,然后因为upstream tomcat1的默认访问页是index.jsp,所以就会访问8081端口的tomcat服务器的index.jsp页面(也就是http://47.91.248.236:8081/index.jsp

    此时当访问www.huohu.com 的时候,就会访问host文件,然后就会去找47.91.248.236 这个ip对应的linux服务器,然后www.huohu.com 默认的端口就是80,所以访问www.huohu.com 的时候,就会找到下面的upstream tomcat2,然后下面的upstream tomcat2就会去找server 47.91.248.236:8082,就会找到8082端口的tomcat服务器,然后因为upstream tomcat2的默认访问页是index.jsp,所以就会访问8082端口的tomcat服务器的index.jsp页面(也就是http://47.91.248.236:8082/index.jsp

    user  root;
    worker_processes  1;
    events {
        worker_connections  1024;
    }
    
    
    http {
        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  65;
    	#配置www.sina.com:80对应的服务器监听端口
    	upstream tomcat1 {
    	server 47.91.248.236:8081;
    	}
    	server {
    	    listen       80;
    	    server_name  www.sina.com;
    	    location / {
    	        proxy_pass   http://tomcat1;
    	        #配置默认访问页,这里就会访问到tomcat1里面的那个index.jsp文件里面
    	        index  index.jsp;
    	    }
    	}
    	
        
        #配置www.houhu.com:80对应的服务器监听端口
        upstream tomcat2 {
    	server 47.91.248.236:8082;
        }
        server {
            listen       80;
            server_name  www.houhu.com;
            location / {
                proxy_pass   http://tomcat2;
                #配置默认访问页,这里就会访问到tomcat2里面的那个index.jsp文件里面
                index  index.jsp;
            }
        }
    }
    
    然后我们访问 www.sina.com

    此时访问到的就是tomcat8081对应的tomcat服务器
    在这里插入图片描述

    然后我们访问 www.huohu.com

    此时访问到的就是tomcat8082对应的tomcat服务器

    在这里插入图片描述

    到此nginx的反向代理就完成了

    能看到这里的同学,觉得好的话就帮忙点个赞吧,Thanks♪(・ω・)ノ

    原文链接

    大佬链接
    https://www.itqiankun.com/article/1564904492

    展开全文
  • 秒懂Java代理与动态代理模式

    万次阅读 多人点赞 2018-06-30 17:08:23
    什么是代理模式?解决什么问题(即为什么需要)?什么是静态代理?什么是动态代理模式?二者什么关系?具体如何实现?什么原理?如何改进?这即为我们学习一项新知识的正确打开方式,我们接下来会以此展开,让你秒懂...
  • 动态代理

    万次阅读 2019-03-21 17:29:55
    动态代理是springaop中底层的实现,主要实现方法就是实现了InvocationHandler接口,并实现invoke方法, 下面是作者写的测试代码,仅供参考。 接口UserService public interface UserService { void add(); ...
  • c++代理

    千次阅读 2011-08-08 16:56:13
    想必大家都知道在浏览器中设置代理吧!?? 其实代理模式跟这个差不多,对象A(相当于浏览器)不是直接访问对象C(相当Web服务器),而是通过一个中间对象B(相当于代理服务器)间接访问对象C。对象B则可以利用这一...
  • 代理模式

    千次阅读 2019-02-28 14:44:48
    大家都知道代理模式深入咱们都业务代码中,(就是代理类把接口都实现类引入进来,然后加以封装,再由其他类使用代理类)应用场景太多了,但是大多都是静态代理,如果真都实现一个动态代理我认为还是一个比较都事情,...
  • 动态代理,大概是Java里最难弄懂的知识点了吧

    千次阅读 多人点赞 2020-06-07 12:36:55
    动态代理与装饰设计模式全面解析
  • Nginx 正向代理和反向代理

    万次阅读 2018-04-20 09:56:53
    最近在捣腾代理,要做个内网yum源代理,之前没接触过代理这些个东西,折腾完记录一下吧。 一、下载源码 目前Nginx一般都是使用源码编译,没有现成的rpm包。下载网址:http://nginx.org/download/。里面有各个...
  • AOP代理

    千次阅读 2019-01-27 23:06:32
    简介 对于使用相同功能代码段的实现方式如下: 图A 复制粘贴实现代码复用对于多处有相同的代码片段再后期维护、升级过程...AOP 代理包含目标对象的所有方法,但是和目标对象方法有所差异,可以在目标对象方法前、后...
  • 局域网内的ubuntu使用代理上网

    千次阅读 2018-10-16 21:54:41
    局域网里的电脑借助另一台电脑上网1. 背景介绍2. 使用Fiddler搭建代理3. ubuntu端设置代理3.1 如果要设置wget的代理3.2 如果使用apt代理3.3 Pip 安装...因此就搭个代理吧。 2. 使用Fiddler搭建代理 首先设置一个代理...
  • 这篇博文,我们以类图和代码的形式来对比学习一下静态代理和动态代理,重点解析各自的优缺点。 定义  代理模式(Proxy Pattern)是对象的结构型模式,代理模式给某一个对象提供了一个代理对象,并由代理对象控制...
  • fiddler设置手机端代理

    千次阅读 2017-12-04 20:30:42
     2、然后找到Connections选项如下图,将Allow remote computers to connect 勾选上(若有提示,确定即可),然后记住默认8888这个端口(可更改...3、OK,下面就是来设置手机代理吧,打开手机WLAN设置,一般长按W
  • 反射技术中有两个很重要的部分,一个是注解,一个是动态代理,刚刚学完代理模式,做一个笔记记录一下~ 什么是代理模式呢,生活中最常见的代理模式应该就是房租中介了吧, 房地产商提供房源,中介与顾客接触,而房...
  • 代理”这个词不陌生吧?买化妆品、买奶粉、买包包,都可以通过代理代购,甚至有专门的代购网站; 或者要购置一些自己不太清楚原理好坏的物品,可以找相关代理负责帮忙购买,当然了,得支付一定费用。 在软件...
  • C++ 代理模式

    千次阅读 2017-11-14 17:50:43
    代理模式(Proxy Pattern)为其他对象提供了一种代理,以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。 简述 模式结构...
  • 正向代理与反向代理通俗理解

    万次阅读 多人点赞 2017-08-22 22:45:25
    关于正向代理以及反向代理的理解。特别通俗,一看就懂。
  • 都什么时代了还在裸爬吗,快用IP代理池吧!

    千次阅读 多人点赞 2020-04-08 10:57:12
    当你经常爬取对方的网站,对方看你,呦这家伙频繁访问也太快了吧,肯定是个爬爬...其实对于Python来说,使用代理代理IP访问是很简单的。就拿我们经常使用的requests库来说,使用代理IP如下: import requests #定义...
  • 爬取代理ip并验证(快代理&西祠代理) ** 最近公司有些爬虫需求,有爬虫,就需要有代理IP池(为什么需要?自己想。),但是吧,只能用免费的,原因都懂,那来吧! 快代理:...
  • intellij idea 设置代理 代理下载

    千次阅读 2020-01-26 16:21:58
    问题描述: 下载一些包时速度很慢, 把下载源切换成国内的镜像后遇到了其他问题(按理说不应该这样, 可能是我哪里操作错了), 最后决定还是走代理下载吧 解决方法: File→Settings→Plugins→设置按钮→ ...
  • nginx反向代理、动静分离、负载均衡

    千次阅读 2017-08-10 00:14:31
    要说反向代理,我们就先要理解正向代理 ,下面我们就谈谈正向代理和反向代理吧。 正向代理 一个位于客户端和原始服务器(origin server)之间的服务器,为了从原始服务器取得内容,客户端向代理发送一个请求并指定...
  • 上网代理及相关知识

    千次阅读 2009-12-15 10:39:00
    教你使用代理吧1.什么是代理服务器及其作用? 代理服务器是网上提供转接功能的服务器,比如你想访问的目的网站是A,由于某种原因你不能访问到网站A或者你不想直接访问网站A(这样通过代理服务器网站A,对网站A而已...
  • 代理模式Proxy深入 动态代理

    千次阅读 2016-03-06 01:56:12
    前一篇文章中介绍了代理模式的概念和一个基本案例代理模式Proxy入门 之帮你追求心仪的姑娘,接下来继续深入学习代理模式一个变种,动态代理。 首先来回顾下代理概念:为一个对象提供代表以控制该对象的访问。上一文...
  • nginx反向代理--负载均衡

    万次阅读 多人点赞 2018-10-19 17:39:37
    同时也是一个IMAP、POP3、SMTP代理服务器;nginx可以作为一个HTTP服务器进行网站的发布处理,另外nginx可以作为反向代理进行负载均衡的实现。 这里主要通过三个方面简单介绍nginx 反向代理 负载均衡 nginx特点 1...
  • 本来打算通过UDP53来绕过认证,在准备实现DNS隧道的时候,发现所涉及的内容实在是太多了…(DNS解析原理,域名的原理,隧道技术,代理技术 and so on),每一个知识点都能让我深入去研究一段时间。因此在实现DNS隧道...
  • Ubuntu 18.04设置中国的代理服务器

    千次阅读 2018-05-29 08:50:32
    是阿里云还是清华的服务器,接下来就让我们一起配置一下服务器代理吧!1、打开Ubuntu 18.04操作系统,点击左下角菜单栏,找到“软件与更新”2、选择服务器代理,这里选择“其他站点”:3、选择最佳服务器:4、开始...
  • 静态代理和动态代理的理解

    万次阅读 多人点赞 2017-08-25 18:04:24
    Java 静态代理 静态代理通常用于对原有业务逻辑的扩充。比如持有二方包的某个类,并调用了其中的某些方法。然后出于某种原因,比如记录日志、打印方法执行时间,但是又不好将这些逻辑写入二方包的方法里。所以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,709
精华内容 73,483
关键字:

代理吧