java

• • 一、代理模式
  • 二、静态代理
  • 三、动态代理

一、代理模式

• 代理模式是一种设计模式,能够使得再不修改源目标的情况下,额外扩展源目标的功能。即通过访问源目标的代理类,再由代理类去访问源目标。这样一来,要扩展功能,就无需修改源目标的代码了。只要在代理上增加就可以了

二、静态代理

• 就是通过声明一个明确的代理类来访问源对象
  假设有一个Person接口和一个Aniaml接口

package StaticProxy;
//里面有wakeup和sleep两个方法
public interface Person {void wakeup();void sleep();
}

package StaticProxy;public interface Animal {void wakeup();void sleep();
}

它们有各自的实现类,以student和dog举例

package StaticProxy;public class Student implements Person{private String name;public Student(String name){this.name = name;}@Overridepublic void wakeup() {System.out.println("学生" + name + "起床了");}@Overridepublic void sleep() {System.out.println("学生" + name + "睡觉了");}
}

package StaticProxy;public class Dog implements Animal{private String name;public Dog(String name){this.name = name;}@Overridepublic void wakeup() {System.out.println("dog" + name + "起床了");}@Overridepublic void sleep() {System.out.println("dog" + name + "睡觉了");}
}

这时候假设我们现在要在wakeup()前增加一行输出"早安",sleep()前增加一行输出"晚安",通过直接修改实现类肯定是不大好的,这里列举了student和dog,肯定会有很多种类,一个个修改工作量太大了,可以针对两个接口实现两个动态代理类

package StaticProxy;public class PersonProxy implements Person{private Person person;public PersonProxy(Person person){this.person = person;}@Overridepublic void wakeup() {System.out.println("早安");person.wakeup();}@Overridepublic void sleep() {System.out.println("晚安");person.sleep();}
}

package StaticProxy;public class AnimalProxy implements Animal{private Animal animal;public AnimalProxy(Person person){this.animal = animal;}@Overridepublic void wakeup() {System.out.println("早安");animal.wakeup();}@Overridepublic void sleep() {System.out.println("晚安");animal.sleep();}
}

如上所示,在代理类中增加打印"早安"和"晚安",最终执行代码如下

package StaticProxy;public class MainApp {public static void main(String[] args) {Person student = new Student("李世民");PersonProxy personProxy = new PersonProxy(student);personProxy.wakeup();personProxy.sleep();Person student1 = new Student("朱元璋");PersonProxy personProxy1 = new PersonProxy(student1);personProxy.wakeup();personProxy.sleep();Animal animal = new Dog("王专家");AnimalProxy animalProxy = new AnimalProxy(animal);animalProxy.wakeup();animalProxy.sleep();Animal animal1 = new Dog("李专家");AnimalProxy animalProxy1 = new AnimalProxy(animal1);animalProxy.wakeup();animalProxy.sleep();}
}

这种模式很好理解,这里用了两个代理类,分别代理了Person和Animal接口,但是缺点也很明显:

• 会存在大量的冗余的代理类,这里演示了两个接口,如果有10个接口,就必须定义10个代理类
• 不易维护,一旦接口更改,代理类和目标类都需要更改

三、动态代理

• 无需声明式的创建java代理类,而是在运行过程中生成"虚拟"的代理类,被classloader加载。从而避免了静态代理那样需要声明大量的代理类
• 动态代理也称为接口代理,说白了只是根据接口"凭空"来生成类,至于具体的执行,都被代理到了InvocationHandler的实现类里

用JDK动态代理实现上述例子

package RunProxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;public class JdkProxy implements InvocationHandler {private Object bean;public JdkProxy(Object bean){this.bean = bean;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String methodName = method.getName();if (methodName.equals("wakeup")){System.out.println("早安");}else if (methodName.equals("sleep")){System.out.println("晚安");}return method.invoke(bean,args);}
}

执行代码

package RunProxy;import StaticProxy.Animal;
import StaticProxy.Dog;
import StaticProxy.Person;
import StaticProxy.Student;
import java.lang.reflect.Proxy;public class MainApp {public static void main(String[] args) {JdkProxy proxy = new JdkProxy(new Student("李世民"));Person student = (Person) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Person.class},proxy);student.wakeup();student.sleep();proxy = new JdkProxy(new Student("朱元璋"));Person student1 = (Person) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Person.class},proxy);student1.wakeup();student1.sleep();proxy = new JdkProxy(new Dog("王专家"));Animal animal = (Animal) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Animal.class},proxy);animal.wakeup();animal.sleep();proxy = new JdkProxy(new Dog("李专家"));Animal animal1 = (Animal) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Animal.class},proxy);animal1.wakeup();animal1.sleep();}
}