代理模式之静态代理

1. 什么是代理模式(proxy)
二十三种设计模式之一，作用是通过提供一个代理类，让我们调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用，让不属于目标方法核心逻辑的代码从目标方法中剥离出来从而实现解耦。调用目标方法前先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能集中在一起有利于统一维护。

使用动态代理

代理模式的作用
通过代理，控制对对象的访问！
可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）

静态代理

静态代理在使用时,需要定义接口,被代理对象与代理对象一起实现相同的接口。在代理对象中，创建被代理对象的实例调用目标方法。加入其他逻辑，实现解耦

案例

计算器接口

public interface Calculator {
    //加减乘除
    int add(int i,int j);
    int sub(int i,int j);
    int mul(int i,int j);
    int div(int i,int j);
}

接口实现类

@Component
public class CalculatorImpl implements Calculator {
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("内部方法，result = " + result);
        return result;
    }

    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("内部方法，result = " + result);
        return result;
    }

    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("内部方法，result = " + result);
        return result;
    }

    public int div(int i, int j) {
        int result = i / j;
        System.out.println("内部方法，result = " + result);
        return result;
    }
}

代理类

@Component
public class CalCulatorProxy implements Calculator{
    @Autowired
    private CalculatorImpl target;

    public int add(int i, int j) {
        System.out.println("日志，方法：add，参数" + i + "," + j);
        int add = target.add(i, j);
        System.out.println("日志，方法：add，结果" + add);
        return add;
    }

    public int sub(int i, int j) {
        System.out.println("日志，方法：sub，参数" + i + "," + j);
        int sub = target.sub(i, j);
        System.out.println("日志，方法：sub，结果" + sub);
        return sub;
    }

    public int mul(int i, int j) {
        System.out.println("日志，方法：mul，参数" + i + "," + j);
        int mul = target.mul(i, j);
        System.out.println("日志，方法：mul，结果" + mul);
        return mul;
    }

    public int div(int i, int j) {
        System.out.println("日志，方法：div，参数" + i + "," + j);
        int div = target.div(i, j);
        System.out.println("日志，方法：div，结果" + div);
        return div;
    }
}

applicationContext.xml

xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.dong.spring.proxy"></context:component-scan>
</beans>

测试

public class TestProxy {
    @Test
    public void testStaticProxy(){
        ApplicationContext context
                = new ClassPathXmlApplicationContext("applicationContext.xml");
        CalCulatorProxy culatorProxy = context.getBean(CalCulatorProxy.class);
        culatorProxy.div(4, 2);
    }
}
//结果
日志，方法：div，参数4,2
内部方法，result = 2
日志，方法：div，结果2

静态代理方式的弊端

静态代理方式是有缺陷的；

1.如果有很多个对象需要找代理，那么就需要实现很多个对象的代理类，这样的话代码臃肿，用户体验很一般；

2.如果被代理的方法过多，每个方法都需要增强，代码不整洁，大量搬用的工作

它有这两大缺陷就造成了写大型项目的时候，就不会用静态代理这个设计模式