设计模式-代理

1.代理模式:通过代理，控制对对象访问。可以详细控制访问某个类(对象)的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理

2.角色：

<1>抽象角色：定义代理角色和真实角色的公共对外方法

<2>真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色使用(关注真正的业务逻辑)

<3>代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作

–将统一的流程控制放到代理角色中进行处理



3.应用场景：

<1>安全代理：屏蔽对真实角色的直接访问

<2>远程代理：通过代理类处理远程方法的调用

<3>延迟加载：先加载轻量级的代理对象，真正需要时再加载真实对象

静态代理(静态定义代理类)

动态代理(动态生成代理类)

<1>jdk自带的动态代理

<2>javaassist字节码操作库实现

<3>CGLIB

<4>ASM(未接触过，底层使用指令，可维护性较差)

4.静态代理示代码:

<1>抽象角色

//抽像角色
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collect();
}

<2>代理角色

//代理角色(拥有对真实角色的引用)
public class ProxyStar implements Star {
private Star star;

public ProxyStar(Star star) {
super();
this.star = star;
}
@Override
public void confer() {
System.out.println("ProxyStar's confer");
}
@Override
public void signContract() {
System.out.println("ProxyStar's signContract");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar's bookTicket");
}
@Override
public void sing() {
star.sing();
}
@Override
public void collect() {
System.out.println("ProxyStar collect");
}
}

<3>真实角色

//真实角色
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar's confer");
}
@Override
public void signContract() {
System.out.println("RealStar's signContract");
}
@Override
public void bookTicket() {
System.out.println("RealStar's bookTicket");
}
@Override
public void sing() {
System.out.println("RealStar(Jay Zhou) sing");
}
@Override
public void collect() {
System.out.println("RealStar collect");
}
}

<4>客户端

public class Client {
public static void main(String[] args) {
Star realStar=new RealStar();
Star proxyStar=new ProxyStar(realStar);
proxyStar.confer();
proxyStar.bookTicket();
proxyStar.signContract();
proxyStar.sing();
proxyStar.collect();
}
}
//执行结果
ProxyStar's confer
ProxyStar's bookTicket
ProxyStar's signContract
RealStar(Jay Zhou) sing
ProxyStar collect

5.动态代理

优点：抽象角色(接口)中声明的方法都被转移到调用处理器的一个方法中集中处理，可以更加灵活地处理众多方法

jdk自带的动态代理:(只能代理接口实现，不能代理抽象类实现 )

-java.lang.reflect.Proxy(动态生成代理类和对象)

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

<1>抽象角色

//抽像角色
public interface Star {
void confer();
void signContract();
void bookTicket();
void sing();
void collect();
}

<2>真实角色

//真实角色
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar's confer");
}
@Override
public void signContract() {
System.out.println("RealStar's signContract");
}
@Override
public void bookTicket() {
System.out.println("RealStar's bookTicket");
}
@Override
public void sing() {
System.out.println("RealStar(Jay Zhou) sing");
}
@Override
public void collect() {
System.out.println("RealStar collect");
}
}

<3>代理类处理器

//代理类处理器
public class StarHandler implements InvocationHandler {
//真实角色
private Star realStar;

public StarHandler(Star realStar) {
super();
this.realStar = realStar;
}
//所有真实角色的方法调用都会集中到invoke方法中进行处理
@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(realStar, args);
}
System.out.println("真实角色方法执行后");
System.out.println("收钱");
return object;
}
}

<4>客户端

public class Client {
public static void main(String[] args) {
Star realStar=new RealStar();
StarHandler handler=new StarHandler(realStar);
Star proxy=(Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class},handler);
proxy.sing();
}
}
//执行结果
真实角色方法执行前
签合同，订票等操作
RealStar(Jay Zhou) sing
真实角色方法执行后
收钱