核心作用:
- 通过代理,控制对对象的访问!
可以详细控制访问某个(某类)对象的方法,在调用这个方法前做前置处理,调用这个方法后做后置处理(即:AOP的微观实现!),从而实现将统一流程代码放到代理类中处理。
- AOP(Aspect Oriented Programming面向切面编程)的核心实现机制!
核心角色
- 抽象角色
定义代理角色和真实角色的公共对外方法。
- 真实角色
实现抽象角色,定义真实角色所要实现的业务逻辑，供代理角色调用。
关注真正的业务逻辑!
- 代理角色
实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。
将统一的流程控制放到代理角色中处理!
应用场景
- 安全代理:屏蔽对真实角色的直接访问。
- 远程代理:通过代理类处理远程方法调用(RMI)。
- 延迟加载:先加载轻量级的代理对象,真正需要再加载真实对象。
比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100M，在打开文件时不可能将所有的图片都显示出来，这样就可以用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
静态代理(静态定义代理类)
代理模式
package proxy.staticProxy;
public interface Star {
void confer(); // 面谈
void signContract(); // 签合同
void bookTicket(); // 订票
void sing(); // 唱歌
void collectMoney(); // 收钱
}
package proxy.staticProxy;
public class RealStar implements Star{
public void confer() {
System.out.println("RealStar.confer()");
}
public void signContract() {
System.out.println("RealStar.signContract()");
}
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
public void sing() {
System.out.println("RealStar(Jay).sing()");
}
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
package proxy.staticProxy;
public class ProxyStar implements Star{
private Star star;
public ProxyStar(Star star) {
this.star = star;
}
public void confer() {
System.out.println("ProxyStar.confer()");
}
public void signContract() {
System.out.println("ProxyStar.signContract()");
}
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}
public void sing() {
star.sing();
}
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}
}
package proxy.staticProxy;
public class Client {
public static void main(String[] args) {
Star Jay = new RealStar();
Star proxy = new ProxyStar(Jay);
proxy.confer();
proxy.signContract();
proxy.bookTicket();
proxy.sing();
proxy.collectMoney();
}
}
输出:
ProxyStar.confer()
ProxyStar.signContract()
ProxyStar.bookTicket()
RealStar(Jay).sing()
ProxyStar.collectMoney()
动态代理(动态生成代理类)
- JDK自带的动态代理
- javaassist字节码操作库实现
- CGLIB
- ASM(底层使用指令,可维护性较差)
动态代理相比于静态代理的优点
- 抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理,这样,我们可以更加灵活和统一的处理众多的方法。
JDK自带的动态代理
- java.lang.reflect.Proxy
作用:动态生成代理类和对象
- java.lang.reflect.InvocationHandler(处理器接口)
可以通过invoke方法实现对真实角色的代理访问。
每次通过Proxy生成代理类对象 对象时都要指定对应处理器
package proxy.dynamicProxy;
public interface Star {
void confer(); // 面谈
void signContract(); // 签合同
void bookTicket(); // 订票
void sing(); // 唱歌
void collectMoney(); // 收钱
}
package proxy.dynamicProxy;
public class RealStar implements Star {
public void confer() {
System.out.println("RealStar.confer()");
}
public void signContract() {
System.out.println("RealStar.signContract()");
}
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}
public void sing() {
System.out.println("RealStar(Jay).sing()");
}
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}
}
package proxy.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler{
Star realStar;
public StarHandler(Star realStar) {
this.realStar = realStar;
}
/**
* @param proxy 指代我们所代理的那个真实对象
* @param method 指代的是我们所要调用真实对象的某个方法的Method对象
* @param args 指代的是调用真实对象某个方法时接受的参数
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object object = null;
// 在代理真实对象前我们可以添加一些自己的操作
System.out.println("真正的方法执行前!");
System.out.println("面谈,签合同,预付款,订机票");
if (method.getName().equals("sing")){
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
object = method.invoke(realStar,args);
}
// 在代理真实对象后我们也可以添加一些自己的操作
System.out.println("真正的方法执行后!");
System.out.println("收尾款");
return object;
}
}
package proxy.dynamicProxy;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
// 我们要代理的真实对象
Star realStar = new RealStar();
// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
StarHandler handler = new StarHandler(realStar);
/**
* 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
* 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
* 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
*/
Star proxy = (Star) Proxy.newProxyInstance(handler.getClass().getClassLoader(), realStar.getClass().getInterfaces(), handler);
proxy.sing();
}
}
网友评论