代理模式的理解

代理模式（横向开发）

代理模式使SpringAOP的底层

代理模式的分类

静态代理

角色分析：

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

理解

package com.dome01;
//客户端访问代理角色
class Client {
    public static void main(String[] args) {
//        代理除了完成原本的任务外，还会生成一些其他的附属操作
        Proxy proxy = new Proxy (new Host ());
        proxy.Rent ();

    }
}
//接口
/**
 * 出租房子的操作
 */
interface Rent {
    public void Rent();
}
//真实角色
/**
 * 房东
 */
class Host implements Rent {

    public void Rent() {
        System.out.println ("房东出租房子");
    }
}
//代理角色
/**
 * 中介帮忙出租房子
 */
class Proxy {
    Host host;

    public Proxy() {
    }

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

    public void Rent() {
        SeeHourse ();
        host.Rent ();
        Money ();
    }

    public void SeeHourse() {
        System.out.println ("中介带人看房子");
    }

    public void Money() {
        System.out.println ("中介收取中介费");
    }
}

代理模式的好处：

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

缺点

• 一个真实角色就会产生一个代理角色，代码量会加倍（动态代理可以解决这个问题）

加深理解

package com.dome02;
//客户端访问代理角色
public class Client {
    public static void main(String[] args) {
        UserServiceImplProxy proxy = new UserServiceImplProxy ();
        proxy.setService (new UserServiceImpl ());
        proxy.add ();
    }
}
//代理角色
class UserServiceImplProxy implements UserService {

    private UserServiceImpl service;

    public void setService(UserServiceImpl service) {
        this.service = service;
    }

    public void add() {
        log ("add");
        service.add ();
    }

    public void delete() {
        log ("delete");
        service.delete ();
    }

    public void update() {
        log ("update");
        service.update ();
    }

    public void select() {
        log ("select");
        service.select ();
    }

    public void log(String name) {
        System.out.println ("调用了" + name + "方法");
    }
}

//真实角色
class UserServiceImpl implements UserService {

    public void add() {
        System.out.println ("新增用户");
    }

    public void delete() {
        System.out.println ("删除用户");

    }

    public void update() {
        System.out.println ("修改用户");

    }

    public void select() {
        System.out.println ("查询用户");

    }
}
//接口
interface UserService {
    public void add();

    public void delete();

    public void update();

    public void select();
}

动态代理

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

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

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

需要了解两个类：Proxy，InvocationHandler

Proxy

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
实现：

方法：

代码理解

package com.dome03;

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

public class Client {
    public static void main(String[] args) {
//        代理角色：现在没有
        Proxys proxys = new Proxys ();
//        通过调用程序处理角色来处理我们要调用的接口对象
        proxys.setRent (new Host ());
        Rent proxy = (Rent) proxys.getProxy ();//动态生成的
        proxy.Rent ();

    }
}

//接口
interface Rent {
    void Rent();
}

//真实代理类
class Host implements Rent {

    public void Rent() {
        System.out.println ("房东租房子");
    }
}

class Proxys implements InvocationHandler {

    //    被代理的接口
    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 {
        SeeHourse ();
//        动态代理的本质，就是使用反射机制实现
        Object invoke = method.invoke (rent, args);
        Money ();
        return invoke;
    }

    public void SeeHourse() {
        System.out.println ("中介带人看房子");
    }

    public void Money() {
        System.out.println ("中介收取中介费");
    }
}

优化，将其封装成一个类，可重复使用

//万能的动态代理类

package com.dome04;

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

public class ProxyInvocationHandler implements InvocationHandler {

    Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    public Object getPorxy() {
        return Proxy.newProxyInstance (this.getClass ().getClassLoader (), target.getClass ().getInterfaces (), this);
    }

    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 ("新增了" + msg + "方法");
    }
}

//调用

package com.dome04;

public class Clinet {
    public static void main(String[] args) {
//        真实对象
        UserServiceImpl userService = new UserServiceImpl ();
        ProxyInvocationHandler handler = new ProxyInvocationHandler ();
        handler.setTarget (userService);
        UserService porxy = (UserService) handler.getPorxy ();
        porxy.add ();
    }
}

class UserServiceImpl implements UserService {

    public void add() {
        System.out.println ("新增用户");
    }

    public void delete() {
        System.out.println ("删除用户");

    }

    public void update() {
        System.out.println ("修改用户");

    }

    public void select() {
        System.out.println ("查询用户");

    }
}

interface UserService {
    public void add();

    public void delete();

    public void update();

    public void select();
}