java设计模式-代理模式

java设计模式-代理模式

---

定义:代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。如图

代理模式中的角色：

1. 抽象主题角色（Subject）：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。
2. 具体主题角色（RealSubject)：也称为委托角色或者被代理角色。定义了代理对象所代表的目标对象。
3. 代理主题角色（Proxy)：也叫委托类、代理类。代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。

代理模式又分为静态代理和动态代理。
 静态代理是由程序猿创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。在编译前进行增强是我们自己写的
 动态代理是在程序运行时，通过运用反射机制动态的创建而成。是不需要我们写代理类的

静态代理

• 代表aspectj

案例1

房东租房子 需要找中介 让中介去找客户 房东只提供租房子的方法 而中介不仅有租房子的方法 还有签合同 还有看房的方法

角色分析：

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

代码步骤：

租房接口

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

2.真实角色房东

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

3.代理角色

//中介
public class Proxy implements Rent{
    //不用继承方式用组合
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }
    @Override
    public void rent() {
        host.rent();
        this.price();
        this.hetong();
    }
    //中介费
    public void price(){
        System.out.println("中介收中介费");
    }
    //合同
    public void hetong(){
        System.out.println("中介签合同");
    }
}

4.客户端访问代理角色

	//房东要租房子
        Host host=new Host();
        //代理，中介帮房东租房子，  中介还会附加一些其他的操作
        Proxy proxy=new Proxy(host);
        //你不用直接面对房东 直接找中介操作
        proxy.rent();

结果

案例2

原有的增删改查接口 需要添加日志功能
在公司不能改变原有的业务代码 ，改动原有代码在公司是大忌！

增删改查接口

public interface UserService {
    void add();
    void dele();
    void update();
    void slect();
}

具体实现类 如果需要添加日志 不能改动原有的代码

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("add");
    }
    @Override
    public void dele() {
        System.out.println("dele");
    }
    @Override
    public void update() {
        System.out.println("update");
    }

    @Override
    public void slect() {
        System.out.println("slect");
    }
}

每次运行方法都需要添加日志接口 又不能改变原有代码
使用代理类来解决
用代理类实现同样的接口。

//在每个方法中加入日志功能
public class UserServiceProxy implements UserService {

    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void dele() {
        log("dele");
        userService.dele();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void slect() {
        log("slect");
        userService.slect();
    }
    public void log(String msg){
        System.out.println("打印了"+msg+"日志");
    }

}

代理的对象拥有一样的方法 对方法进行添加日志方法。
测试类

public static void main(String[] args) {

        UserServiceImpl userService=new UserServiceImpl();

        UserServiceProxy proxy=new UserServiceProxy();
        proxy.setUserService(userService); //将被代理类组合进来
        proxy.add();
        proxy.dele();
        proxy.slect();

    }

运行结果

代理模式的好处：

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

缺点：

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

要是每一个代理类都产生一个代理角色 这样代码量太多了 我们要怎么解决呢
->为了解决这个问题 我们使用动态代理

---

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是我们动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口—JDK动态代理
  • 基于类: cglib
  • java字节码实现: javasist

需要了解两个类：

Proxy:提供了创建动态代理类和实例的静态方法 static 可用直接调用proxy.方法

接口 invocationHandler:调用处理程序 处理代理实例并返回结果

传入的invocationHandler接口 是 实现类 重写的invoke方法会进行增强

我们可以直接new 然后用匿名内部类的方式 只需要重写invoke接口 invoke接口
接口实现的invoke方法 执行代理类的每一个方法都会经过invoke方法

我们继续将上面的例子使用动态代理

首先先是一个接口 有一个租房功能

public interface cent {

    void cent();
}

房东

public class host implements cent{
    @Override
    public void cent() {
        System.out.println("房东卖房子");
    }
}

生成代理类的方法

public class proxy1 implements InvocationHandler {

    private cent host;

    public void setTarget(cent host) {
        this.host = host;
    }

    //得到生成的代理类
    public Object getProxy(){
        /**
         * Proxy.newProxyInstance(目标代理类的类加载器，目标代理类的接口，InvocationHandler接口)
         * InvocationHandler:用于实现增强的方法  接口内 主要实现invoke方法   每使用一次方法都会经过invoke
         */
        Object ProxyTarget = Proxy.newProxyInstance(host.getClass().getClassLoader(),
                host.getClass().getInterfaces(), this);
        return ProxyTarget;
    }

    /**
     * 处理代理实例，并返回结果
     * 每次目标代理类的对象调用方法  都会经过下面的方法进行增强
     * 这个方法是 实现了InvocationHandler接口中重写的方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //日志方法
        hetong();
        Object invoke = method.invoke(host, args);
        return invoke;

    }

    public void hetong(){
        System.out.println("签合同");
    }

}

测试

public static void main(String[] args) {
        //真实角色
        host host=new host();
        //组合目标代理对象
        proxy1 proxy1=new proxy1();  //该类实现了invocationhandler类
        proxy1.setTarget(host);

        cent proxyhost = (cent) proxy1.getProxy();  //获得目标代理类的对象
        //使用代理类来租房子
        proxyhost.cent();

我们也可以写一个通用的返回代理类的方法

参数为Obj 只需要传入 被代理类的方法 在invoke写需要增强的代码即可

动态代理好处：

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

---

面试题

JDK动态代理和Cglib动态代理的区别

SrpingAop中的动态代理有2种，一种是JDK的动态代理，另一种是Cglib的动态代理

• JDK动态代理只提供接口的代理，不支持类的代理。核心InvocationHandler接口和Proxy类，InvocationHandler 通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。

• 如果代理类没有实现 InvocationHandler 接口，那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB（Code Generation Library），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP。CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。

静态代理与动态代理区别在于生成AOP代理对象的时机不同，相对来说AspectJ的静态代理方式具有更好的性能，但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理。

InvocationHandler 的 invoke(Object proxy,Method method,Object[] args)：proxy是最终生成的代理实例; method 是被代理目标实例的某个具体方法; args 是被代理目标实例某个方法的具体入参, 在方法反射调用时使用。