核心作用
- 通过代理，控制对对象的访问！
- 可以详细控制访问某个（某类）对象的方法，在调用这个方法钱做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）
- AOP（Aspect Oriented Programming面向切面编程）的核心实现机制
核心角色：
- 抽象角色
- 定义代理角色和真实角色的公共对外方法
- 真实角色：
- 实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用
- 关注真正的业务逻辑！
- 代理角色：
- 实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
- 将统一的流程控制放到代理角色中处理！
应用场景：
- 安全代理：拼比对真实角色的直接访问
- 远程访问：通过代理处理方法调用（RMI）
- 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。
分类：
- 静态代理（静态定义代理类）
- 动态代理（动态生成代理类）
- JDK自带的动态代理
- Javaassist字节码操作库实现
- CGLIB
- ASM（底层使用指令，可维护性较差）
个人理解
其实代理模式在生活中还真是很常见，用一句话来讲：
专业的事让专业的人来
打官司让律师来代理，租房找租房中介来代理，做产品让技术团队来代理。。。。
小栗子
案例：歌星出演，经纪人代理
package com.principle.staticproxy;
public interface Star {
//面谈
void confer();
//签合同
void signContract();
//订票
void bookTicket();
//唱歌
void sing();
//收钱
void getMoney();
}
package com.principle.staticproxy;
public class RealStar implements Star{
@Override
public void confer() {
System.out.println("confer");
}
@Override
public void signContract() {
System.out.println("signContract");
}
@Override
public void bookTicket() {
System.out.println("bookTicket");
}
@Override
public void sing() {
System.out.println("sing");
}
@Override
public void getMoney() {
System.out.println("getMoney");
}
}
package com.principle.staticproxy;
public class ProxyStar implements Star {
private Star star;
public ProxyStar(Star star) {
super();
this.star = star;
}
@Override
public void confer() {
star.confer();
}
@Override
public void signContract() {
star.signContract();
}
@Override
public void bookTicket() {
star.bookTicket();
}
@Override
public void sing() {
star.sing();
}
@Override
public void getMoney() {
star.getMoney();
}
}
package com.principle.staticproxy;
public class Client {
public static void main(String[] args) {
Star reStar=new RealStar();
ProxyStar proxyStar=new ProxyStar(reStar);
proxyStar.confer();
proxyStar.signContract();
proxyStar.bookTicket();
proxyStar.sing();
proxyStar.getMoney();
}
}
结果打印：
confer
signContract
bookTicket
sing
getMoney
staticproxy.png
动态代理相比静态代理的优点
- 抽象角色中（接口）声明的所有方法都可以被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
JDK自带的动态代理
- java.lang.reflect.Proxy
- 作用：动态生成代理类和对象
- java.lang.reflect.InvocationHandler（处理器接口）
- 可以通过invoke方法实现对真实角色的代理访问。
- 每次通过Proxy生成代理类对象时都要指定对应的处理器对象
小栗子
package com.principle.dynamicproxy;
public interface Star {
//面谈
void confer();
//签合同
void signContract();
//订票
void bookTicket();
//唱歌
void sing();
//收钱
void getMoney();
}
package com.principle.dynamicproxy;
public class RealStar implements Star{
@Override
public void confer() {
System.out.println("confer");
}
@Override
public void signContract() {
System.out.println("signContract");
}
@Override
public void bookTicket() {
System.out.println("bookTicket");
}
@Override
public void sing() {
System.out.println("sing");
}
@Override
public void getMoney() {
System.out.println("getMoney");
}
}
package com.principle.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class StarHandler implements InvocationHandler {
Star realStar;
public StarHandler(Star realStar) {
super();
this.realStar = realStar;
}
@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;
}
}
package com.principle.dynamicproxy;
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
Star realStar=new RealStar();
StarHandler handler=new StarHandler(realStar);
Star star=(Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Star.class}, handler);
star.sing();
}
}
打印结果:
真正的方法执行着
面谈，签合同，预付款，订机票
sing
真正的方法执行者
收尾款
dynamicproxy.png
参考：
网友评论