Java 为什么需要用到代理

为什么？

在平时我们写java代码的时候，是不是一个类都是只处理自己相关的业务，不会去处理多余的代码。每个类都尽量做到独立，这样才能做到高内聚低耦合，为了以后的代码维护和扩展。
那么问题来了，如果哪天我们需要在类里加上权限，日志等功能时，我们是不是需要修改每个类。这样不仅工作量巨大，严重影响代码质量。这时我们需要一个代理，让我们可以在不
改动原有代码的前提下，实现一些其他功能，即增强。我们在进入目标类之前，先进入代理类，在代理类中写我们需要的额外功能，这样原有类不动，不影响原有功能。

代码示例

程序员类:

public class Programmer {
    public void goToWork() {
        System.out.print("开始上班了\n");
    }

    public void goOffWork() {
        System.out.print("终于下班了\n");
    }
}

main:

public class ProxyDemoApplication {
    public static void main(String[] args) {
        Programmer programmer = new Programmer();
        programmer.goToWork();
        programmer.goOffWork();
    }
}

这是一个很简单的例子，现在如果我们需要记录 上班，下班的时间，简单的方法肯定是直接在方法上改，加上时间，如下：

public void goToWork() {
    System.out.print("开始上班了 时间:" + new Date() + "\n");
}

这样虽然能实现功能，但是需求去改原有类的代码。如果我们在项目中遇到像这样的情况，在很多类中方法上都需要加上时间，然后我们去一个个改是不是很崩溃，第一个很累，第二个容易遗漏，第三个后面假如在改
又要来一次。所以我们引入代理，省时省力省脑。下面看看使用静态代理怎么处理的。

静态代理实现示例

需要有个接口，通过接口来实现

/**
* 共同接口
*/
public interface ProgrammerInterface {
    void goToWork();

    void goOffWork();
}

程序员类实现接口方法

/**
* 程序员类
*/
public class Programmer implements ProgrammerInterface{
    @Override
    public void goToWork() {
        System.out.print("开始上班了\n");
    }

    @Override
    public void goOffWork() {
        System.out.print("终于下班了\n");
    }
}

程序员代理类，同样的实现接口方法，代理类中会去调用目标类(程序员类，通过构造函数)

/**
* 程序员代理类
*/
public class ProgrammerProxy implements ProgrammerInterface {
    //目标类(程序员类)
    Programmer programmer;


    //构造方法,初始化目标类
    public ProgrammerProxy(Programmer programmer) {
        this.programmer = programmer;
    }


    @Override
    public void goToWork() {
        System.out.print("进入了上班代理\n");
        programmer.goToWork();
        System.out.print("上班时间为:" + new Date() + "\n\n");
    }


    @Override
    public void goOffWork() {
        System.out.print("进入了下班代理\n");
        programmer.goOffWork();
        System.out.print("下班时间为:" + new Date() + "\n");
    }
}

main

public class ProxyDemoApplication {

    public static void main(String[] args) {
//        Programmer programmer = new Programmer();
//        programmer.goToWork();
//        programmer.goOffWork();


        Programmer programmer = new Programmer();
        ProgrammerProxy programmerProxy = new ProgrammerProxy(programmer);
        programmerProxy.goToWork();
        programmerProxy.goOffWork();
    }
}

运行结果

是不是实现了相同的功能，且没有去怎么改变原有类的代码。通过实现共同接口，做到在代理类中处理增强代码，新增的逻辑，然后在代理类中再去调用目标类，
做到不改变原有类的代码，实现新的功能，这就是代理的作用。

以上是静态代理，使用静态代理会有一个问题。如果后面还有其它类也需要实现这样的功能怎么办？比如医生类里面也有上下班，也需要记录时间，但是方法名什么的都不一样，
无法做到实现共同接口，那我们是不是还得去写个医生类代理类，这样是不是遇到一个就要写一个，很麻烦。想要解决这样的问题，我们就需要使用java的动态代理，动态代理通过
反射去实现相同的功能。动态代理后面说。。。

  来源：https://blog.csdn.net/u013419838/article/details/93071611

标签：System,Programmer,Java,void,代理,public,programmer,用到
来源： https://www.cnblogs.com/konglxblog/p/16441416.html