1、代理模式

为什么要学习代理模式？

因为这就是springAOP的底层！【springAOP和springMVC】

代理模式的分类：

静态代理
动态代理

1.1、静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人！

代码步骤：

1.接口 ——Rent

//出租房子
public interface Rent {void rent();
}

2.真实角色——Host

//房东
public class Host implements Rent {@Overridepublic void rent() {//打印System.out.println("房东有房子出租！");}
}

3.代理角色——Proxy

//中介
public class Proxy implements Rent {private Host host;public Proxy() {}public Proxy(Host host) {this.host = host;}@Overridepublic void rent() {host.rent();seeHouse();hetong();fare();}public void seeHouse() {//打印System.out.println("See House 看房子");}public void hetong(){//打印System.out.println("签约租凭合同");}public void fare(){//打印System.out.println("收取中介费用!");}
}

4.客户端访问代理角色——Client

public class Client {//这是一个main方法，是程序的入口：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 delete();public void update();public void query();
}

UserServiceImpl——真实对象

//真实对象
public class UserServiceImpl implements UserService{@Overridepublic void add() {System.out.println("增加了一个用户");}@Overridepublic void delete() {System.out.println("删除了一个用户");}@Overridepublic void update() {System.out.println("修改了一个用户");}@Overridepublic void query() {System.out.println("查询了一个用户");}
}

UserServiceProxy——代理

public class UserServiceProxy implements UserService{private UserServiceImpl userService;public void setUserService(UserServiceImpl userService) {this.userService = userService;}@Overridepublic void add() {log("add");userService.add();}@Overridepublic void delete() {log("delete");userService.delete();}@Overridepublic void update() {log("update");userService.update();}@Overridepublic void query() {log("query");userService.query();}//日志方法public void log(String msg){System.out.println("使用了"+msg+"方法");}
}

加粗样式Client

public class Client {public static void main(String[] args) {UserServiceImpl userService = new UserServiceImpl();UserServiceProxy proxy = new UserServiceProxy();proxy.setUserService(userService);proxy.add();}
}

1.3、动态代理

动态代理和静态代理角色一样

动态代理的代理类是动态生成的，不是我们直接写好的！

动态代理分为两大类：基于接口的动态代理，基于类的动态代理

基于接口-JDK 动态代理【我们在这里使用】
基于：cglib
java字节码实现：javasist

需要了解两个类：

Proxy：代理，
InvocationHandler：调用处理程序，是由代理实例的调用处理程序实现的接口。

在这里插入图片描述

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)                    //返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。  /**
所需三个参数参数 
loader - 类加载器来定义代理类 ，需要一个
interfaces - 代理类实现的接口列表 
h - 调度方法调用的调用处理函数 newProxyInstance，方法有三个参数：
loader: 用哪个类加载器去加载代理对象
interfaces/：动态代理类需要实现的接口
h：动态代理方法在执行时，会调用h里面的invoke方法去执行
*//**
* ClassLoader loader 类加载器，用于加载代理对象的字节码
* Class<?>[] interfaces 字节码数组，用于让代理对象和被代理对象有相同的方法
* InvocationHandler h 处理方法，用于方法增强
*/Object invoke(Object proxy, 方法 method, Object[] args) //处理代理实例上的方法调用并返回结果。  /**
* Object proxy 被代理的类
* Method method 被代理类的方法
* Object[] args 方法参数
*/

ProxyInvocationHandler

//自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {//被代理的接口private Rent rent;public void setRent(Rent rent) {this.rent = rent;}//生成代理类public Object getProxy() {//第一个参数：目标对象类的加载器，第二个参数：目标对象相同的接口字节码对象数组，第三个参数：InvocationHandler对象return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);}//调用代理对象的任何方法，实质执行的都是invoke方法@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {seeHouse();//动态代理的本质，就是使用反射机制实现的Object invoke = method.invoke(rent, args);//目标方法hetong();fare();return invoke;}public void seeHouse() {//打印System.out.println("See House 看房子");}public void hetong() {//打印System.out.println("签约租凭合同");}public void fare() {//打印System.out.println("收取中介费用!");}}

Client

public class Client {//这是一个main方法，是程序的入口：public static void main(String[] args) {//真实角色Host host = new Host();//代理角色。ProxyInvocationHandler pih = new ProxyInvocationHandler();//通过调用处理角色来处理我们调用的接口对象pih.setRent(host);Rent proxy =(Rent) pih.getProxy();proxy.rent();}
}

真正动态

public class ProxyInvocationHandler implements InvocationHandler {//被代理的接口private Object target;public void setTarget(Object target) {this.target = target;}//生成得到代理类public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(),this);}//处理代理实例，返回结果@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {log(method.getName());Object result = method.invoke(target,args);return result;}public void log(String msg){System.out.println("执行了"+msg+"方法");}}

import com.blue.demo02.UserService;
import com.blue.demo02.UserServiceImpl;public class Client {public static void main(String[] args) {//真实角色UserServiceImpl userService = new UserServiceImpl();//代理角色：现在没有ProxyInvocationHandler pih = new ProxyInvocationHandler();pih.setTarget(userService);//通过调用程序处理角色 来处理我们要调用的接口对象UserService proxy = (UserService) pih.getProxy();proxy.delete();}
}