设计模式-代理模式

为了理解Spring中的核心之一AOP，学习该代理模式

静态代理模式的好处：
可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
公共业务发生扩展时，方便集中管理！
代理模式的缺点
一个真实角色就会产生一个代理角色,代码量会翻倍,开发效率会变低

静态代理

案例1：租房

• 图示
  

• 需要实现的接口

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

• 真实对象：房东

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

• 代理对象：中介

public class HostProxy implements Rent {

    private Host host;

    public HostProxy() {
    }

    public HostProxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        host.rent();
        check();
        sign();
    }

    public void check() {
        System.out.println("中介带租客看房");
    }

    public void sign() {
        System.out.println("中介与租客签合同");
    }
	
}

• 客户租房

public class Client {
    public static void main(String[] args) {
        // 被代理的对象：要出租房屋的房东
        Host host = new Host();

        // 代理对象：中介。
        // 除了帮助房东完成出租任务，还会进行看房、签合同操作
        HostProxy hostProxy = new HostProxy(host);

        // 租客不需要面对房东，找到中介即可完成租房
        hostProxy.rent();
    }
}

案例2：助理老师上课

• 需要实现的接口

public interface ITeacherDao {
    void teach();
}

• 真实对象：老师

public class TeacherDao implements ITeacherDao {
    @Override
    public void teach() {
        System.out.println("老师授课中......");
    }
}

• 代理对象：助理老师

public class TeacherDaoProxy implements ITeacherDao {

    private ITeacherDao target;

    public TeacherDaoProxy(ITeacherDao target) {
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("授课前准备");
        target.teach();
        System.out.println("准备");
    }
}

• 助理老师上课

public class Client {
    public static void main(String[] args) {
        // 被代理对象：原来的老师
        TeacherDao teacherDao = new TeacherDao();

        // 代理对象：助理老师
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);

        teacherDaoProxy.teach();
    }
}

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

动态代理

动态代理中的代理对象由代理工厂生成

案例：助理老师sayHello

• 需要实现的接口

public interface ITeacherDao {
    void sayHello(String name);
}```

• 老师

public class TeacherDao implements ITeacherDao {
    @Override
    public void sayHello(String name) {
        System.out.println("hello " + name + "!");
    }
}

• 核心：代理工厂

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    /*
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

    ClassLoader loader 被代理对象，即目标对象的类加载器
    Class<?>[] interfaces  被代理对象，即目标对象实现的接口
    InvocationHandler h 执行被代理对象的方法时，会把当前执行的被代理对象方法作为参数传入
     */

    public Object getProxyObject() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("两人遇到了");
                        Object returnValue = method.invoke(target, args);
                        System.out.println("打招呼结束");
                        return returnValue;
                    }
                });
    }
}

• 测试一下

public class Client {
    public static void main(String[] args) {
        // 创建被代理对象
        TeacherDao teacherDao = new TeacherDao();

        // 给被代理对象创建代理对象
        ITeacherDao proxyObject = (ITeacherDao) new ProxyFactory(teacherDao).getProxyObject();

        proxyObject.sayHello("Tom");
    }
}