1、静态代理

角色分析：

抽象角色：一般会使用接口或抽象类来解决
真实角色：被代理角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作

测试代码

1、接口

package com.xg.demo01;

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

2、真实角色

package com.xg.demo01;

// 房东
public class Host implements Rent {

    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3、代理角色

package com.xg.demo01;

public class Proxy implements Rent {
    private Host host;
    public Proxy() {
    }
    public Proxy(Host host) {
        this.host = host;
    }
    @Override
    public void rent() {
        host.rent();
        seeHost();
        contract();
        fare();
    }
    // 看房
    public void seeHost() {
        System.out.println("中介带你看房。");
    }
    // 签合同
    public void contract() {
        System.out.println("签租赁合同");
    }
    // 收中介费
    public void fare() {
        System.out.println("中介，收中介费。");
    }
}

4、客户端访问代理

package com.xg.demo01;

public class Client {
    public static void main(String[] args) {
        // 房东有房子出租
        Host host = new Host();

        // 代理，中介帮房东出租房子，但是代理角色一般会有一些附属操作！
        Proxy proxy = new Proxy(host);

        // 不用面对房东，直接找中介即可
        proxy.rent();
    }
}

代理模式的好处

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给了代理！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！

缺点：

一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低

为什么要添加代理类

改变原有的业务代码在公司中是大忌
原则：尽量不要改变原有的代码

加深理解

1、接口

package com.xg.demo02;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

2、真实角色

package com.xg.demo02;

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

3、代理角色

package com.xg.demo02;

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

4、客户端访问代理

package com.xg.demo02;

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

        userServiceProxy.add();
    }
}

2、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口：JDK动态代理【使用】
- 基于类：cglib
- Java字节码：javasist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

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

每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。
Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

测试代码

1、接口

package com.xg.demo03;

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

2、真实角色

package com.xg.demo03;

// 房东
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3、InvocationHandler 自动生成代理

package com.xg.demo03;

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);
    }
    // 处理代理实例并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = method.invoke(rent, args);
        seeHost();
        contract();
        fare();
        return invoke;
    }
    public void seeHost() {
        System.out.println("中介带你看房。");
    }
    public void contract() {
        System.out.println("签租赁合同");
    }
    public void fare() {
        System.out.println("中介，收中介费。");
    }
}

4、代理对象

package com.xg.demo03;

public class Client {
    public static void main(String[] args) {
        // 真实角色
        Host host = new Host();

        // 代理角色：暂时没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        // 通过调用程序处理角色来处理要调用的接口对象！
        pih.setRent(host); // 这里的proxy就是动态生成的，并没有写
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

加深理解

代理 UserService

InvocationHandler 自动生成代理

package com.xg.demo04;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 使用这个类，自动生成代理类！
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);
    }
    // 处理代理实例并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object invoke = method.invoke(target, args);
        return invoke;
    }
    public void log(String msg) {
        System.out.println("[DEBUG]执行了" + msg + "方法");
    }
}

Client

package com.xg.demo04;

import com.xg.demo02.UserService;
import com.xg.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.add();
    }
}

动态代理的好处

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给了代理！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！
一个动态代理类代理的是一个接口，一般是对应一类业务
一个动态代理可以代理多个类，只要实现了同一个接口