一、概述
1、重要性
为什么要学习代理模式？因为这就是SpringAOP的底层原理！
面试必问：Spring AOP 与 Spring MVC；
2、代理模式的分类
静态代理；
动态代理；
3、什么是代理模式
参考：【Java设计模式】001-代理模式
二、静态代理
1、角色分析
抽象角色：
一般会使用接口或抽象类来解决（比如：租房）；
真实角色：
被代理的角色（比如：房东）；
代理角色：
代理角色，代理真是角色后，一般会做一些附属操作（比如：租房中介）；
客户：
访问代理对象的人（比如：租客）；
2、代码实现
第一步：新建一个Moudle，创建房东与中介的公共租房接口
package com.zibo.demo01;
//代理角色和被代理角色的公共接口，因为代理角色要帮被代理角色完成其需要做的事情
//出租接口，房东要出租房子，中介就要帮房东出租房子，所以出租房子这个事情是二者都要做的
//写一个公共接口使其二者都实现改接口，即可达到约束二者都做同一件事情的目的
public interface Rent {
void rent();
}
第二步：创建房东类，实现租房接口
package com.zibo.demo01;
//被代理对象——房东，房东只做一件事情，就是出租房子，其他啥都不想干
//房东实现出租接口
public class Landlord implements Rent {
@Override
public void rent() {
System.out.println("房东将房子出租！");
}
}
第三步：创建中介代理类，实现租房接口
package com.zibo.demo01;
//代理角色，需要帮助被代理角色完成出租房子的事情
//中介肯定是要为房东出租房子的，所以必须和房东一起实现出租接口
//但是代理对象往往还有做一些其他附属操作，中介要做一些其他工作来完成房子出租的整个流程
public class Agent implements Rent {
private Landlord landlord;
public Agent() {
}
public Agent(Landlord landlord) {
this.landlord = landlord;
}
@Override
public void rent() {
seeHouse();
landlord.rent();
signAContract();
charge();
}
private void seeHouse(){
System.out.println("中介带租客看房子！");
}
private void signAContract(){
System.out.println("中介与租户签合同！");
}
private void charge(){
System.out.println("中介向租户收取中介费！");
}
public Landlord getLandlord() {
return landlord;
}
public void setLandlord(Landlord landlord) {
this.landlord = landlord;
}
}
第四步：创建客户租房测试类
package com.zibo.demo01;
//客户类，租户租房子去找中介租
public class User {
public static void main(String[] args) {
//实例化房东
Landlord landlord = new Landlord();
//实例化中介
Agent agent = new Agent(landlord);
//通过中介租房子
agent.rent();
}
}
测试结果：
中介带租客看房子！
房东将房子出租！
中介与租户签合同！
中介向租户收取中介费！
3、代理模式的好处
可以使真实角色（被代理角色）的业务更加纯粹；
公共业务交给代理代理角色，实现了业务分工；
公共业务发生扩展的时候，方便集中管理；
4、代理模式的缺点
一个真实角色（被代理角色）就会产生一个代理角色，代码量会翻倍！
三、深入静态代理
1、搭建环境
第一步：写一个UserService接口
package com.zibo.demo02;
public interface UserService {
void save();
void delete();
void update();
void query();
}
第二步：写一个UserService接口的实现类
package com.zibo.demo02;
public class UserServiceImpl implements UserService {
@Override
public void save() {
System.out.println("保存了一个用户！");
}
@Override
public void delete() {
System.out.println("删除了一个用户！");
}
@Override
public void update() {
System.out.println("更新了一个用户！");
}
@Override
public void query() {
System.out.println("查询了一个用户！");
}
}
第三步：写客户端类进行测试
package com.zibo.demo02;
public class Client {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
userService.save();
}
}
测试结果：
保存了一个用户！
2、问个问题
假如我们要在各个方法执行的前后做一些事情，我们该怎么办？难道要在所有方法前后修改代码？如此：
package com.zibo.demo02;
public class UserServiceImpl implements UserService {
@Override
public void save() {
System.out.println("保存用户前要做的事情");
System.out.println("保存了一个用户！");
System.out.println("保存用户后要做的事情");
}
@Override
public void delete() {
System.out.println("删除用户前要做的事情");
System.out.println("删除了一个用户！");
System.out.println("删除用户后要做的事情");
}
@Override
public void update() {
System.out.println("更新用户前要做的事情");
System.out.println("更新了一个用户！");
System.out.println("更新用户后要做的事情");
}
@Override
public void query() {
System.out.println("查询用户前要做的事情");
System.out.println("查询了一个用户！");
System.out.println("查询用户后要做的事情");
}
}
这岂不是很反人性！！！
忽然想起刚才演示的房东、中介和租客的代理模式，不由得我们心生一计！
3、正所谓：自己动手，丰衣足食
第一步：我们新建一个代理类UserAgent
package com.zibo.demo02;
public class UserAgent implements UserService {
private UserService userService;
public UserAgent() {
}
public UserAgent(UserService userService) {
this.userService = userService;
}
private void doSthBefore(){
System.out.println("在此之前做一些事情");
}
private void doSthAfter(){
System.out.println("在此之后做一些事情");
}
private void doSthAfter2(){
System.out.println("在此之后再做一些事情");
}
@Override
public void save() {
doSthBefore();
userService.save();
doSthAfter();
doSthAfter2();
}
@Override
public void delete() {
doSthBefore();
userService.delete();
doSthAfter();
doSthAfter2();
}
@Override
public void update() {
doSthBefore();
userService.update();
doSthAfter();
doSthAfter2();
}
@Override
public void query() {
doSthBefore();
userService.query();
doSthAfter();
doSthAfter2();
}
}
第二步：将UserServiceImpl改回去
package com.zibo.demo02;
public class UserServiceImpl implements UserService {
@Override
public void save() {
System.out.println("保存了一个用户！");
}
@Override
public void delete() {
System.out.println("删除了一个用户！");
}
@Override
public void update() {
System.out.println("更新了一个用户！");
}
@Override
public void query() {
System.out.println("查询了一个用户！");
}
}
第三步：修改测试类
package com.zibo.demo02;
public class Client {
public static void main(String[] args) {
UserService service = new UserServiceImpl();
UserAgent agent = new UserAgent(service);
agent.save();
}
}
测试结果：
在此之前做一些事情
保存了一个用户！
在此之后做一些事情
在此之后再做一些事情
发生了什么：
我们在没有修改UserServiceImpl类的情况下，对UserServiceImpl类的功能进行了增强！
这就是AOP的底层原理！
四、动态代理
1、静态代理有一个很严重的缺点
一个真实角色（被代理角色）就会产生一个代理角色，代码量会翻倍！
怎么办：
既然静态代理一个真实角色都会产生一个代理角色，导致代码量翻倍，那么我们让每一个代理角色自动生成不就不会代码量翻倍了吗！
2、动态代理概述
①动态代理和静态代理角色一样；
②动态代理的代理类是动态生成的，不是直接写好的；
③动态代理分为两大类：基于接口的动态代理、基于类的动态代理；
基于接口：JDK动态代理（我们本次使用的）；
基于类：cglib；
java字节码：javasist；
3、需要了解两个类
Proxy类：
代理；
InvocationHandler类：
调用处理程序；
4、让我们来尝试一下实现动态代理
（我们在静态代理的代码上进行修改：租房案例）
第一步：写一个自动生成代理角色的类
package com.zibo.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ProxyInvocationHandler implements InvocationHandler {
//第一步：指定代理谁
private Object target;
//无参构造
public ProxyInvocationHandler() {
}
//带参构造
public ProxyInvocationHandler(Object target) {
this.target = target;
}
//第二步：生成代理对象
public Object getProxyObject(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
/**
* 第三步：执行代理对象的方法
* @param proxy 代理对象（不可直接用没需用target）
* @param method 所执行的方法
* @param args 给所执行的方法传的参数
* @return 返回执行结果
* @throws Throwable 异常
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("方法执行之前可执行其他内容");
Object invoke = method.invoke(target, args);
System.out.println("方法执行之后可执行其他内容");
return invoke;
}
}
第二步：修改User测试类
package com.zibo.demo03;
//客户类，租户租房子去找中介租
public class User {
public static void main(String[] args) {
//实例化房东
Landlord landlord = new Landlord();
//生成代理对象：中介
ProxyInvocationHandler handler = new ProxyInvocationHandler(landlord);
Rent rent = (Rent) handler.getProxyObject();
//使用代理对象
rent.rent();
}
}
测试结果：
方法执行之前可执行其他内容
房东将房子出租！
方法执行之后可执行其他内容
备注：
自动生成代理角色的类不太好理解，可根据其中注释理解，另一方面，这个类的写法基本是固定的；
这就是AOP的底层原理！
