提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
1、静态代理
1.1静态代理实现
角色分析
- 抽象角色:一般会使用接口或抽象类来解决
- 真实角色:被代理的角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人
代码步骤
- 接口
public interface Rent {
public void rent();
}
- 真实角色
//房东
public class Host implements Rent {
public void rent() {
System.out.println("房东出租房子");
}
}
- 代理角色
public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent() {
seeHouse();
host.rent();
contract();
fare();
}
//看房子
public void seeHouse(){
System.out.println("看房子");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
//合同
public void contract(){
System.out.println("租赁合同");
}
}
- 客户端访问代理角色
public class Client {
public static void main(String[] args) {
//房东租房子
Host host = new Host();
//代理,中介帮忙租房子,但是代理角色会有附属操作!
Proxy proxy = new Proxy(host);
//不用面对房东,直接找中介租房即可。
proxy.rent();
}
}
代理模式的好处
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共业务交给大力角色,实现了业务的分工
- 公共业务扩展的时候,方便集中管理
缺点 - 一个真实角色会产生一个代理角色;代码量翻倍,开发效率变低
1.2、加深理解
原本业务
- UserService接口
public interface UserService {
public void add();
public void dele();
public void update();
public void query();
}
- UserServiceImpl类
public class UserServiceImpl implements UserService{
public void add() {
System.out.println("增加了一个用户");
}
public void dele() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("修改");
}
public void query() {
System.out.println("查询");
}
}
现在增加一个业务,每次的操作加一个日志
此时加入代理
新增一个类
public class UserSeiviceProxy implements UserService{
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
userService.add();
}
public void dele() {
log("dele");
userService.dele();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
//日志方法
public void log(String msg){
System.out.println("[Debug]使用了"+ msg+"方法");
}
}
看起来我们的代码反而多了使用起来不方便了,但是如果我们直接在原有的UserServiceImpl上进行修改,增加新的功能,如果一旦出现错误进行修改时将会十分麻烦
2、动态代理
2.1动态代理实现
- 动态代理和静态代理角色一样
- 动态代理的动态类是动态生成的,不是我们直接写好的
- 动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口----JDK动态代理【我们在这里使用的】
- 基于类----cglib
- java字节码实现Javassist
需要了解的两个类:Proxy:代理,InvocationHandler:调用处理程序
【InvocationHandler:调用处理程序】
Object invoke(Object proxy, 方法 method, Object[] args);
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接
//口,它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列,或null如果接口方法没有参数。
//原始类型的参数包含在适当的原始包装器类的实例中,例如java.lang.Integer或java.lang.Boolean。
【Proxy : 代理】
代码实现:
抽象角色和真实角色和之前的一样!
Rent.java即抽象角色
public interface Rent {
public void rent();
}
Host.java即真实角色
//房东
public class Host implements Rent {
public void rent() {
System.out.println("房东出租房子");
}
}
ProxyInvocationHandler. java 即代理角色
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//使用该类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}
//处理代理实例,并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质就是使用反射机制实现
seeHouse();
Object invoke = method.invoke(rent, args);
fare();
return invoke;
}
public void seeHouse(){
System.out.println("中介带看房子");
}
public void fare(){
System.out.println("收中介费");
}
}
Client . java
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理角色:现在没有
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy();//这里的Proxy就是动态生成的,我们没有写
proxy.rent();
}
}
2.2动态代理的好处
静态代理有的它都有,静态代理没有的,它也有!
- 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
- 公共的业务由代理来完成 . 实现了业务的分工 ,
- 公共业务发生扩展时变得更加集中和方便 .
- 一个动态代理 , 一般代理某一类业务
- 一个动态代理可以代理多个类,代理的是接口!