代理

最新推荐文章于 2024-08-14 15:52:18 发布
最新推荐文章于 2024-08-14 15:52:18 发布
阅读量565 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/everyonetimeismoney/article/details/27382081

高质量技术免费分享

https://blog.youkuaiyun.com/everyonetimeismoney/article/details/94412711

某信：13126570759

 

 

用代码来简单看看代理模式

 

★有个类

class A{

 void sayHello(){

     System.out.println("we like ZhangXiaoXiang teacher");----------------------位置1

 }

}

现在我想在位置1的代码打印输出前或后，打印点其他的比如System.out.println("we like HeiMaXuenLianYing!");，但是这时候我没有源文件(.java文件)改不了源码，我只能调用A类中的sayHello方法，那怎么办呢？

★这时候我们就可以用代理模式带实现这一需求，重新定义一个类（A对象的代理类）

package shipin49;

/**
 * A类的代理
 *
 * @author Terry
 * @date 2014-5-29
 *
 */
public class AProxy {
 public void sayHello(){
  A a = new A();
  //附加的代码
  System.out.println("we like HeiMaXuenLianYing1!");
  a.sayHello();
  System.out.println("we like HeiMaXuenLianYing2!");
 }
}

★在main方法中运行如下代码

public static void main(String[] args) {
  // TODO Auto-generated method stub
  //客户端不直接找被代理的对象（厂家）,而是找代理商
  AProxy aproxy = new AProxy();
  aproxy.sayHello();
  //直接找厂家失去了代理意义
  System.out.println("--------------------------------");
  A a = new A();
  a.sayHello();
 }

★输出结果

we like HeiMaXuenLianYing1!
we like ZhangXiaoXiang teacher
we like HeiMaXuenLianYing2!
--------------------------------
we like ZhangXiaoXiang teacher

★感觉代理模式和装饰者模式很相像。装饰者模式重点在于添加附加行为修饰被装饰者，而代理模式的重点则是代替本人作业，减少对实际对象的操作。

 

AOP（面向切面编程）

★什么是AOP？

1、AOP

      Aspect（方面 ）Oriented（导向）Programming（程序设计）:意为：面向切面（行为）编程，通过预编译方式和运行期动态代理来实现程序功能的统一维护的一种技术。是函数式编程的一种衍生泛型。AOP在其他领域有其他含义。它是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。[1]

2、函数式编程（直白的说函数式编程就是方法编程----这是我的理解）   

      函数式编程是种编程典范，它将电脑运算视为函数的计算。函数编程语言最重要的基础是 λ 演算（lambda calculus）。而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。和过程化编程相比，函数式编程里，函数的计算可随时调用。

3、更加详细的AOP参照http://baike.baidu.com/subview/73626/13548606.htm?fr=aladdin（百度百科）

★张孝祥老师视频中的AOP解说

   ●系统中存在着许多交叉业务，一个交叉业务就是要切入到系统中的一个方面，如下所示

 

                                                              安全                       事物                          日志

      StudentService-----------------------------|------------------------|--------------------------|-----------------------------

      管理学生信息的类（管理学生模块）  |                             |                               |

      CourseService------------------------------|------------------------|--------------------------|-----------------------------

      管理课程信息的类 （管理课程模块） |                             |                               |

      ClassroomService--------------------------|------------------------|------------------------- |-----------------------------

      管理教室信息的类（管理教室模块）

    上面的这3个类，他们各管各的事，互不往来，但是他们都要有安全，都要处理事物，都要写日志，而安全、事物、日志都贯穿到了许多个模块当中，于是这3个功能就成了模块的交叉业务  。它们就是交叉业务，穿插到了许多的类当中。

   ●用具体的程序代码描述交叉业务：

     method1  （模块1）                     method2 （模块2）                            method3（模块3）

     {                                                    {                                                           { 

     -------------------------------------------------------------------------------------------------------切面 （在方法的这个位置，都要他们有日志功能或安全功能亦或其他的功能）

     .............                                        ..............                                              ............                    

     -------------------------------------------------------------------------------------------------------切面                                                                                                              

     }                                                    }                                                           }          

    ●交叉业务的编程问题即为面向方面的编程，AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，如下所示：

    -------------------------------------------------------------------------------------------------------切面 （在方法的这个位置，都要他们有日志功能或安全功能亦或其他的功能）

    method1  （模块1）                     method2 （模块2）                              method3（模块3）

     {                                                    {                                                           { 

 

     .............                                        ..............                                              ............                    

 

     }                                                    }                                                           }            

     -------------------------------------------------------------------------------------------------------切面 （在方法的这个位置，都要他们有日志功能或安全功能亦或其他的功能）

     ●使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术。

动态代理技术

1、★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

★要为系统中的各种接口增加代理功能，如果用静态代理，那将需要再增加和系统中的接口一样多的代理类，那样工程量很大，也太麻烦。

★JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用做代理，既动态代理。

★JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类代理。（如果不实现一个或多个接口，那JVM生成的动态类就没有方法，一个没有方法的类那来做什么呢？这样意义不大。）

★如果有一个类它没有实现任何接口，那此时要动态的生成此类的代理，但是JVM生成的又必须要实现一个或多个接口，这时候怎么办呢？可以使用第三方的CGLIB库来动态生成此类的代理。

★代理的内容可以放在目标方法的什么位置呢？

    void proxyMothod(){

            位置1----------------在调用目标方法之前

            try{

                 targetMothod();

            }catch(Exception e){

            位置2-----------------在调用目标方法异常的cath语句中

            }

             位置3----------------在调用目标方法之后

    }

★打印动态代理生成的字节码中的方法

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  //一般情况下类加载器都是用和接口一样的，但是你可以用其他的类加载器类，clazzProxy1动态代理加载的类
  Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
  System.out.println("字节码名字："+clazzProxy1.getName());
  //获得动态代理生成的类的构造方法
  Constructor[] constructors = clazzProxy1.getConstructors();
  for (Constructor constructor : constructors) {
   StringBuilder sb = new StringBuilder();
   sb.append("构造方法："+constructor.getName()+"(");
   for (Class clazz : constructor.getParameterTypes()) {
    sb.append(clazz.getName().substring(clazz.getName().lastIndexOf(".")+1)+",");
   }
   sb.deleteCharAt(sb.lastIndexOf(","));
   sb.append(");");
   System.out.println(sb);
  }
  /**
   * 打印其他方法
   */
  for (Method constructor : clazzProxy1.getMethods()) {
   StringBuilder sb = new StringBuilder();
   sb.append("其他方法："+constructor.getName()+"(");
   for (Class clazz : constructor.getParameterTypes()) {
    sb.append(clazz.getName().substring(clazz.getName().lastIndexOf(".")+1)+",");
   }
   if(sb.lastIndexOf(",")!=-1){
    sb.deleteCharAt(sb.lastIndexOf(","));
   }
   sb.append(");");
   System.out.println(sb);
  }
 }

运行输出：

$Proxy0
构造方法：$Proxy0(InvocationHandler);
其他方法：add(Object);
其他方法：equals(Object);
其他方法：toString();
..........

2、创建动态类的实例对象

问题一：

public static void main(String[] args) throws Exception {

Class clazz = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
          clazz.newInstance();
}

上面的代码可以运行吗？

答：不可以，因为clazz没有无参的构造函数方法。

示例代码:

 

/**
   * 内部类
   * Invocation(调用)Handler(处理程序)
   * @author Terry
   * @date 2014-5-29
   *
   */
  class MyInvocationHander1 implements InvocationHandler{

   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;-------------------------------------------------------------------------3
   }
   
  }
  //获得动态代理的字节码，Collection是个接口
  Class clazz = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
  //获得构造函数，不能使用clazz.newInstance()因为clazz没有无参的构造函数
  Constructor con = clazz.getConstructor(InvocationHandler.class);
  //用构造函数创建一个新的对象new MyInvocationHander1()自定义的InvocationHandler
  Collection collection = (Collection)con.newInstance(new MyInvocationHander1());
  Collection test = null;
  System.out.println(collection);//这里的结果为空，但是有2中情况，一种是对象为空，一种是toString()的返回值为空
  System.out.println(test);
//  System.out.println(collection.toString());-------------------------------------1
//  System.out.println(test.toString());---------------------------------------------2

在main方法中运行输出：

null
null

★将位置1的代码取消注释运行输出：

null
null
null

★将位置2的代码取消注释运行报空指针异常

★注销位置2的代码，更改位置3的代码为：return "wahaha";运行输出：

wahaha
null
wahaha

★判断对象是否为空System.out.println(collection==null);运行输出：false;

匿名内部类的写法：

//new InvocationHandler();new InvocationHandler(){},大括号的意义，不是很懂
  Collection collection2 = (Collection)con.newInstance(new InvocationHandler(){
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;
   }
   
 })；

Proxy另一种newProxyInstance方法

static ObjectnewProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
          返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

这方法和上面的示例代码的效果是一样的。

方法一、

public void dynamicProxy(){
  Object object = Proxy.newProxyInstance(System.class.getClassLoader(), new Class[]{Collection.class}, new InvocationHandler() {
   
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;
   }
  });  
  printMethodName(object.getClass());
 }

方法二、
 /**
  * 打印一个类中的所有方法
  * @param clazz1
  */
 public static void printMethodName(Class clazz1){
  for (Method constructor : clazz1.getMethods()) {
   StringBuilder sb = new StringBuilder();
   sb.append("其他方法："+constructor.getName()+"(");
   for (Class clazz : constructor.getParameterTypes()) {
    sb.append(clazz.getName().substring(clazz.getName().lastIndexOf(".")+1)+",");
   }
   if(sb.lastIndexOf(",")!=-1){
    sb.deleteCharAt(sb.lastIndexOf(","));
   }
   sb.append(");");
   System.out.println(sb);
  }
 }

方法三、

在main方法中调用：

ProxyTest pt = new ProxyTest();
  pt.dynamicProxy();

运行输出：

其他方法：add(Object);
其他方法：equals(Object);
其他方法：toString();
其他方法：hashCode();
其他方法：clear();

...............

问题二、Object object = Proxy.newProxyInstance(System.class.getClassLoader(), new Class[]{Collection.class,Date.class}, new InvocationHandler()...将代码改成这个程序报错,原因仔细看了帮助文档后明白了。

示例代码：

public void dynamicProxy(){
  Collection collectionProxy = (Collection)Proxy.newProxyInstance(
    System.class.getClassLoader(),
    new Class[]{Runnable.class,Comparable.class,Collection.class},
    new InvocationHandler() {
    ArrayList target = new ArrayList();//被代理的对象，Collection间接的实现类
   @Override
   /**
    *
    * @param proxy:代理对象（JVM动态生成的）
    * @param method：被调用的方法
    * @param args：方法中的参数

    * @return :返回方法的返回值
    */
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    System.out.println("=====================================================");
//    ArrayList target = new ArrayList();//被代理的对象，Collection间接的实现类
//    System.out.println(proxy);
    System.out.println(method.getName());
    if(args!=null){
     for (Object object : args) {
      System.out.println(object);
     }
    }   
    //在调用目标之前做点什么
    System.out.println("附加的内容1");
    Object objct = method.invoke(target, args);
    //在调用目标之后做点什
    System.out.println("附加的内容2");
    return objct;
   }
  });
//  System.out.println(object);
//  printMethodName(object.getClass());
  collectionProxy.add("zxx");
  collectionProxy.add("lhm");
  collectionProxy.remove("lhm");
  collectionProxy.add(new ArrayList().add(new ArrayList().add("hahahaha")));-----------------------------------这里输出true的原因是，方法添加成功所以为true
  System.out.println("大小是多少:" + collectionProxy.size());
 }

在main方法中运行：

ProxyTest pt = new ProxyTest();
  pt.dynamicProxy();输出结果：

=====================================================
add
zxx
附加的内容1
附加的内容2
=====================================================
add
lhm
附加的内容1
附加的内容2
=====================================================
remove
lhm
附加的内容1
附加的内容2
=====================================================
add
true
附加的内容1
附加的内容2
=====================================================
size
附加的内容1
附加的内容2
大小是多少:2

自己写的一个小型的通用性动态代理框架

★接口

/**
 * 功能程序的接口
 *
 * @author Terry
 * @date 2014-5-30
 *
 */
public interface Advice {
 public void before();
 public void laster();
}

★接口的实现类

类1

/**
 * 功能程序1
 *
 * @author Terry
 * @date 2014-5-30
 *
 */
public class MyAdvice1 implements Advice {

 @Override
 public void before() {
  // TODO Auto-generated method stub
  System.out.println("MyAdvice1开始");
 }

 @Override
 public void laster() {
  // TODO Auto-generated method stub
  System.out.println("MyAdvice1结束");
 }

}

类2

/**
 * 功能程序2
 *
 * @author Terry
 * @date 2014-5-30
 *
 */
public class MyAdvice2 implements Advice {

 @Override
 public void before() {
  // TODO Auto-generated method stub
  System.out.println("MyAdvice2开始");
 }

 @Override
 public void laster() {
  // TODO Auto-generated method stub
  System.out.println("MyAdvice2结束");
 }

}

通用性动态代理框架

/**
  * 自己写的一个小型的通用性动态代理框架
  * @param target:被代理的目标类
  * @param advice：忠告，建议的意思。这里是代理目标方法调所附加的代码。（安全、事务、日志等）
  * @return 返回目标方法返回的结果
  */
 private static Object getProxy(final Object target,final Advice advice) {
  Object proxy = (Object)Proxy.newProxyInstance(
    System.class.getClassLoader(),
    target.getClass().getInterfaces(), 
     new  InvocationHandler() {
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
       throws Throwable {
      // TODO Auto-generated method stub
      advice.before();
      System.out.println("方法："+method.getName()+":参数"+args[0]);
      Object object1 = method.invoke(target, args);
      advice.laster();
      return object1;
     }
    });
  return proxy;
 }

在main方法中运行如下代码：

Collection proxy1 =  (Collection)getProxy(new ArrayList(),new MyAdvice1()); 
  Serializable proxy3 =  (Serializable)getProxy(new ArrayList(),new MyAdvice1());//proxy1,proxy3为什么对的？Serializable和Collection是ArrayList的接口
  //ArrayList proxy4 =   (ArrayList)getProxy(new ArrayList(),new MyAdvice1());//错误为什么？

  //System.out.println(proxy1.getClass());输出打印：class $Proxy0，由此可以知道getProxy方法返回的是一个JVM动态生成的代理类，而此类继承了Serializable和Collection接口，在上面的框架方法中target.getClass().getInterfaces(), 有所体现,但是此类没有继承ArrayList,因为JVM动态生成的代理类必须继承接口。

proxy3.equals("22");
  System.out.println(proxy1.getClass());
  proxy1.add("zxx");
  proxy1.equals("333");
  Runnable proxy2 = (Runnable) getProxy(new Thread(),new MyAdvice2());
  proxy2.equals("aaa");

运行输出：

MyAdvice1开始
方法：equals:参数22
MyAdvice1结束
class $Proxy0
MyAdvice1开始
方法：add:参数zxx
MyAdvice1结束
MyAdvice1开始
方法：equals:参数333
MyAdvice1结束
MyAdvice2开始
方法：equals:参数aaa
MyAdvice2结束

模拟Sptring框架（Spring的两大核心Bean工厂和AOP框架）

类1、

package shipin56;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import shipin49.Advice;
/**
 * Java,BeanFactory工厂类：用来创建动态代理
 * 这里与之相关的应该是简单工厂设计模式吧
 * @author Terry
 * @date 2014-5-30
 *
 */
public class BeanFactory {
	Properties props = new Properties();
	/**
	 * 将xml文件以流的方式传进来
	 * @param ips,键值对的流
	 */
	public BeanFactory(InputStream ips){
		try {
			props.load(ips);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			//做商业性项目要做异常处理
			e.printStackTrace();
		}
	}
	
	/**
	 * 获得Bean对象，如果找到的类是ProxyFactoryBean类型的，这返回此代理工厂生产的代理类JavaBean
	 * @param name，在xml中键值对的key值
	 * @return JavaBean
	 */
	public Object getBean(String name){
		//获取xml中，key键为name的值
		String className = props.getProperty(name);
		Object bean = null;
		try {
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();
			//如果获得的bean对象是ProxyFactoryBean代理工厂类型的
			if (bean instanceof ProxyFactoryBean){
				ProxyFactoryBean pfb = (ProxyFactoryBean) bean;
				Advice advice = (Advice) Class.forName(props.getProperty(name+".advice")).newInstance();
				Object target = Class.forName(props.getProperty(name+".target")).newInstance();
				//设置切面对象（安全、事务、日志）
				pfb.setAdvice(advice);
				//设置被代理的目标
				pfb.setTarget(target);
				Object proxy = pfb.getProxy();
				//返回代理对象
				return proxy;
			}
		} catch (Exception e) {
		
		}
		//返回其他对象
		return bean;
	}
}

类2

package shipin56;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import shipin49.Advice;

/**
 * 在Spring中，这里用的是接口,为了灵活吧
 * 代理工厂类
 * @author Terry
 * @date 2014-5-30
 *
 */
public class ProxyFactoryBean {

	/**
	 * 获得代理对象
	 * @return 代理对象
	 */
	public Object getProxy() {
		Object proxy = (Object)Proxy.newProxyInstance(
				//用被代理类的类加载器加载动态对象
				target.getClass().getClassLoader(), 
				//为代理类指定接口
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					/**
					 * 
					 */
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						// TODO Auto-generated method stub
						advice.before();
						System.out.println("我在InvocationHandler类中的invoke()方法中："+proxy.getClass().getName());
						System.out.println("代理："+proxy.getClass().getName()+"方法："+method.getName()+":参数"+args[0]);
						Object object1 = method.invoke(target, args);
						advice.laster();
						return object1;
					}
				});
		return proxy;
	}
	
	
	//目标类
	private Object target;
	//切面对象
	private Advice advice;
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	public Advice getAdvice() {
		return advice;
	}
	public void setAdvice(Advice advice) {
		this.advice = advice;
	}

	
}


类3：main方法

package shipin56;

import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;


public class Main {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		InputStream ips = Main.class.getResourceAsStream("config.properties");
		Object bean = new BeanFactory(ips).getBean("xxx");
		Collection col = (Collection)bean;
		col.add("aaa");
		
	}
}

接口类

 

package shipin49;
/**
 * 功能程序的接口
 * 
 * @author Terry
 * @date 2014-5-30
 *
 */
public interface Advice {
	public void before();
	public void laster();
}

 

 

 

 

 

实现类1

 

package shipin49;

/**
 * 功能程序1
 *
 * @author Terry
 * @date 2014-5-30
 *
 */
public class MyAdvice1 implements Advice {

	@Override
	public void before() {
		// TODO Auto-generated method stub
		System.out.println("MyAdvice1开始");
	}

	@Override
	public void laster() {
		// TODO Auto-generated method stub
		System.out.println("MyAdvice1结束");
	}

}

 

 

 

 

 

实现类2

 

package shipin49;

/**
 * 功能程序2
 *
 * @author Terry
 * @date 2014-5-30
 *
 */
public class MyAdvice2 implements Advice {

	@Override
	public void before() {
		// TODO Auto-generated method stub
		System.out.println("MyAdvice2开始");
	}

	@Override
	public void laster() {
		// TODO Auto-generated method stub
		System.out.println("MyAdvice2结束");
	}

}

 

 

 

 

 

XML配置，XML文件取名config.properties

#xxx=java.util.ArrayList
xxx=shipin56.ProxyFactoryBean
xxx.advice=shipin49.MyAdvice1
xxx.target=java.util.ArrayList

运行程序输出结果：

MyAdvice1开始
我在InvocationHandler类中的invoke()方法中：$Proxy0
代理：$Proxy0方法：add:参数aaa
MyAdvice1结束

将XML里面的配置中的xxx.advice的值改为xxx.advice=shipin49.MyAdvice2运行输出：

MyAdvice2开始
我在InvocationHandler类中的invoke()方法中：$Proxy0
代理：$Proxy0方法：add:参数aaa
MyAdvice2结束

知识点：

Proxy类

static Class<?>getProxyClass(ClassLoader loader,Class<?>... interfaces)
          返回代理类的 java.lang.Class 对象，并向其提供类加载器和接口数组。
static ObjectnewProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
          返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

Invocation(调用)Handler（处理程序）类

Objectinvoke(Object proxy,Method method,Object[] args)
          在代理实例上处理方法调用并返回结果。

Properties类

 voidload(InputStream inStream)
          从输入流中读取属性列表（键和元素对）。

Class类

 URLgetResource(String name)
          查找带有给定名称的资源。

 

23中常用的设计模式之-----------------------红酒经销：代理模式

 











柯南721
关注
代理服务器：转发代理和反向代理是如何工作的？
网易搬砖头
04-02 5万+
这意味着如果多个用户请求相同的内容，代理可以从其缓存中提供该内容，而不是每次都从外部服务器获取内容，从而缩短加载时间并减少带宽。客户端向特定网址发送请求，反向代理将该请求转发到其背后的适当服务器。：关心隐私的个人可能会使用转发代理来隐藏他们访问的网站的 IP 地址和其他识别信息，从而难以跟踪他们的 Web 浏览活动。：它们将传入的网络流量分布在多个服务器上，确保没有任何一台服务器获得过多的负载，并防止任何服务器成为瓶颈。本质上，它接收来自客户端的请求，将其转发到相关服务器，然后将服务器的响应返回给客户端。
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
热门推荐
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
SpringMVC常见的参数接收大全
小小程序员的博客
04-12 1500
一篇文章让你彻底搞懂到底该如何传参和接收参数, 在写代码时, 后端经常需要定义控制层的参数, 比如我需要这个这个或者这种格式那种格式的参数, 定义好之后, 在前端去调接口, 却发现接收不了的情况. 接下来我们就总结一下各种情况定义的参数, 应该如何接收.我们从前端调接口的情况分析出几种传参的类, 大致分为两种。
应用安全-软件安全-漏洞CVE整理
weixin_30865427的博客
07-01 1876
jira ssrf CVE-2019-8451 url = url + '/plugins/servlet/gadgets/makeRequest?url=' + host + '@www.baidu.com/' ImageMagick RCE CVE-2016-3714 axis2 弱口令 任意文件读取 Awstats 路径泄露 h...
利用腾讯云独立IP使用windows用CCProxy搭建Socks5多IP代理服务器图文教程实现单窗口单IP
jianzhandaren的博客
09-07 2万+
腾讯云独立IP使用CCProxy搭建Socks5多IP代理服务器图文教程实现单窗口单IP 目录 腾讯云独立IP使用CCProxy搭建Socks5多IP代理服务器图文教程实现单窗口单IP 1、腾讯云介绍 2、腾讯云购mai 3、创建弹性网卡，绑定弹性公网IP 4、服务器网卡绑定内网IP 5、搭建Socks5服务 6、设置完成 7.socks5IP如何使用 实现 端游 模拟器 手机 ...
使用 nginx 搭建代理服务器（正向代理 https 网站）指南
墨鸦的博客
08-14 3万+
使用 nginx 搭建代理服务器（正向代理 https 网站）指南
java基础-静态代理与动态代理
qq_27246079的博客
08-16 2968
再说一个真实场景帮助大家理解，当我们进行Android开发时会用到网络请求框架，比如最早使用的是Volley框架，之后我想换成okhttp框架，如果之前是强关联（即在业务代码中直接引用Volley），想要做框架替换无疑是痛苦的，如果在设计之初，我们写了一个代理层则可以快速进行框架转换，哪怕将来要求替换为Retrofit也会毫不费力，代理模式可以增强我们代码的扩展性。首先需要说明的是静态代理和动态代理的思想和原理是一模一样的，只是实现代理类的方式不同。正因静态代理的缺点，由此引出动态代理。...
CGLIB 动态代理
m0_61609890的博客
03-11 7188
目录 CGLIB 动态代理 简单结构: 添加依赖 定义类 CGLIB 动态代理 JDK的动态代理机制只能代理实现了接口的类。而不能实现接口的类就不能使用JDK的动态代理，CGLIB是针对类来实现代理的，它的原理是对指定目标类生成一个子类，并覆盖其中的方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 简单结构: 实现原理:继承思想 代理类继承目标类，重写目标类中的方法， CGLIB像是一个拦截器，在调用我们的代...
静态代理理解
qq_55756037的博客
05-31 3451
静态代理
Nginx代理配置
Ben_10_的博客
07-26 1万+
是指客户端通过代理服务器来访问目标服务器，目标服务器不知道真正的客户端是谁，只知道请求来自于代理服务器。是指客户端通过代理服务器来访问目标服务器集群，客户端不知道真正的目标服务器是哪一个，只知道请求发送到了代理服务器。
gost 多级代理
网络安全。
01-15 5231
1、代理链原理，首先需要把最外层跳板机的流量带出来（Frp或gost都可以实现），内层流量（二层、三层、四层等等）代理主要是在每层对应的主机开启gost socks5端口，主要分为非转发代理（./gost -L=socks5://:8899）和转发代理（./gost -L=socks5://:8899 -F=socks5://192.168.202.130:9999），二层推荐非转发代理开启，三层推荐转发代理开启。2、若第二层主机可以访问第三层主机，第三层代理主机不能访问第二层主机，则代理无效。
动态代理(JDK动态代理)初步详解
m0_62933942的博客
02-28 4404
本章当中使用到的名词是: 1.目标类：实现了功能接口的实现类对象 2.代理类：作为调用类和目标类之间的桥接 3.调用类：需要调用目标类方法来完成值的获取 4.OCP原则：程序设计的一个考虑，类设计的时候尽量避免方法当中代码的二次修改 但是欢迎类设计者扩展一个类的功能（方法） 5.耦合度：一个类过于依赖于另一个类，就会产生耦合性 为什么要使用到代理? 我们在之前的学习当中，我们经常使用到一个类去调用另一个类的方法去获取到需要的值 例：1.创建了一个...
代理模型MATLAB工具箱（FAC Viana）
12-21
代理：克里金法，多项式响应面，径向基神经网络和支持向量回归。 错误和交叉验证的分析：留一法和k折交叉验证，以及经典的错误分析（确定系数，标准误差;均方根误差等;）。 基于代理的优化：高效的全局优化（EGO）...
java实现免费代理IP的获取方式 并实时校验代理IP是否有效
09-30
Java 实现免费代理IP的获取方式 并动态实时校验是否有效，java文件项目内含有Jsoup的Jar包（Jsoup是加工过的，含请求），有2个主入口程序： 其一：用于请求代理IP，并立即校验是否是一个有效的代理IP，如果有效，...
绩效考核方案(前端部门)修改版.(1).doc
07-28
绩效考核方案(前端部门)修改版.(1).doc
解决Keil调试时"cannot access target shutting down debug session"错误
07-28
解决Keil调试时"cannot access target shutting down debug session"错误
2018年度计算机教师个人工作小结与2018年度语文教学个人年终工作总结小学范文汇编(1).doc
07-28
2018年度计算机教师个人工作小结与2018年度语文教学个人年终工作总结小学范文汇编(1).doc
【车间调度】基于GA PSO SAA COTS多种优化算法的车间调度比较附Matlab代码.rar
最新发布
07-28
2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
计算机通信工程一计算机网络专业知识(1).pptx
07-28
计算机通信工程一计算机网络专业知识(1).pptx
掌握IP代理技术：免费工具与WPE协同使用
标题“IP免费代理”所指向的知识点，涉及互联网技术中的代理服务器概念以及其在网络安全与隐私保护方面的作用。代理服务器作为一种特殊的网络服务，主要用于允许用户间接访问互联网。它在用户与目标网站之间起到一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值