核心作用

通过代理,控制对对象的访问。可以详细控制访问某个(某类)对象的方法,在调用这个方法前做前置处理,调用这个方法后做后置处理。从而实现将统一流程代码放到代理类中处理。(即:AOP的微观实现!)

AOP(Aspect Oriented Programming面向切面编程)的核心实现机制



核心角色

  • 抽象角色:定义代理角色和真实角色的公共对外方法
  • 真实角色:实现抽象角色,定义真实角色所要实现的业务逻辑,供代理角色调用。(关注真正的业务逻辑)
  • 代理角色: 实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。(将统一的流程控制放到代理角色中处理)




应用场景

  • 安全代理:屏蔽对真实角色的直接访问
  • 远程代理:通过代理类处理远程方法调用(RMI)
  • 延迟加载:先加载轻量级的代理对象,真正需要再加载真实对象。(图片延迟加载)



分类

  • 静态代理(静态定义代理类)
  • 动态代理(动态生成代理类)
    • JDK自带的动态代理
    •  javaassist字节码操作库实现


静态代理



功能接口:原本明星一个人要干的事情

package 设计模式.代理模式.静态代理;

/**
* 原本明星本人一个人干的事情
*
* @author 陈霓清
*/
public interface 功能接口 {
/**
* 面谈
*/
void confer();

/**
* 签合同
*/
void signContract();

/**
* 订票
*/
void bookTicket();

/**
* 唱歌
*/
void sing();

/**
* 收钱
*/
void collectMoney();
}

真实明星实现功能接口

package 设计模式.代理模式.静态代理;

public class 真实明星 implements 功能接口 {

@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}

@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}

@Override
public void confer() {
System.out.println("RealStar.confer()");
}

@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}

@Override
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}

}

经纪人

package 设计模式.代理模式.静态代理;

public class 经纪人 implements 功能接口 {

private 功能接口 star;

public 经纪人(功能接口 star) {
super();
this.star = star;
}

@Override
public void bookTicket() {
System.out.println("ProxyStar.bookTicket()");
}

@Override
public void collectMoney() {
System.out.println("ProxyStar.collectMoney()");
}

@Override
public void confer() {
System.out.println("ProxyStar.confer()");
}

@Override
public void signContract() {
System.out.println("ProxyStar.signContract()");
}

@Override
public void sing() {
// 真实明星做的事情
star.sing();
}

}

客户端调用

package 设计模式.代理模式.静态代理;

public class Client {
public static void main(String[] args) {
功能接口 star = new 真实明星();
功能接口 proxy = new 经纪人(star);

proxy.confer();
proxy.signContract();
proxy.bookTicket();

proxy.sing(); // 真实明星做的事情

proxy.collectMoney();

}
}



动态代理相比于静态代理的优点

抽象角色中(接口)声明的所以方法都被转移到调用处理器一个集中的方法中处理,这样,我们可以更加灵活和统一的处理众多的方法。



JDK自带的动态代理

  •  java.lang.reflect.Proxy
    • 作用:动态生成代理类和对象
  •  java.lang.reflect.InvocationHandler(处理器接口)
    •  可以通过invoke方法实现对真实角色的代理访问
    • 每次通过Proxy生成代理类对象对象时都要指定对应的处理器对象



功能接口

package 设计模式.代理模式.动态代理;

public interface 功能接口 {
/**
* 面谈
*/
void confer();
/**
* 签合同
*/
void signContract();
/**
* 订票
*/
void bookTicket();
/**
* 唱歌
*/
void sing();
/**
* 收钱
*/
void collectMoney();
}

真实明星实现类

package 设计模式.代理模式.动态代理;

public class 真实明星 implements 功能接口 {

@Override
public void bookTicket() {
System.out.println("RealStar.bookTicket()");
}

@Override
public void collectMoney() {
System.out.println("RealStar.collectMoney()");
}

@Override
public void confer() {
System.out.println("RealStar.confer()");
}

@Override
public void signContract() {
System.out.println("RealStar.signContract()");
}

@Override
public void sing() {
System.out.println("RealStar(周杰伦本人).sing()");
}

}

ProxyStar.java

package 设计模式.代理模式.动态代理;

/**
* 模拟动态生成的代理的结构
*
* @author 陈霓清
*/
public class ProxyStar implements 功能接口 {

StarHandler handler;

public ProxyStar(StarHandler handler) {
super();
this.handler = handler;
}

public void bookTicket() {
// handler.invoke(this,当前方法 , args);
}

public void collectMoney() {
// handler.invoke(this,当前方法 , args);
}

public void confer() {
// handler.invoke(this,当前方法 , args);
}

public void signContract() {
// handler.invoke(this,当前方法 , args);
}

public void sing() {
// handler.invoke(this,当前方法 , args);
}

}

StarHandler.java

package 设计模式.代理模式.动态代理;

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

public class StarHandler implements InvocationHandler {

功能接口 star;

public StarHandler(功能接口 star) {
super();
this.star = star;
}

@Override
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")) {
object = method.invoke(star, args);
}

System.out.println("真正的方法执行后!");
System.out.println("收尾款");

return object;
}

}

客户端调用:Client.java

package 设计模式.代理模式.动态代理;

import java.lang.reflect.Proxy;

public class Client {

public static void main(String[] args) {
功能接口 star = new 真实明星();
StarHandler handler = new StarHandler(star);

功能接口 proxy = (功能接口) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),
new Class[]{功能接口.class}, handler);

proxy.sing();
}

}




回到顶部