代理模式——静态代理（贴近业务）

静态代理概念：所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了，通常用于对原有业务逻辑的扩充。

举例理解：以结婚为例，当事人只需要处理自己的主要事儿即可，比如典礼、洞房，其他的杂事儿可以交给代理公司即可

静态代理需要满足三点：

1、需要有真实角色

2、需要有一个代理角色

3、这两个角色之间必须实现相同的接口

静态代理类优缺点
优点：1，可以使真实角色的操作更加纯粹!不用去关注一些公共的业务。2，公共也就交给代理角色!实现了业务的分工。3，公共业务发生扩展的时候，方便集中管理!
缺点：1，代理对象的一个接口只服务于一种类型的对象，如果要代理的接口很多，势必要为每一个接口都进行代理，势必会新增很多代理类，静态代理在程序规模稍大时就无法胜任了。2，如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

public interface UserService {
    public void add();
    public void select();
    public void delect();
}
public class UserServiceImp implements UserService{
    @Override
    public void add() {
        System.out.println("执行的添加方法");
    }
    @Override
    public void select() {
        System.out.println("执行的查询方法");
    }
    @Override
    public void delect() {
        System.out.println("执行的删除方法");
    }
}

比如现在有这么个业务。service出问题了项目经理需要你跟service添加一个日志方法，你可能立马会想到在原有的类上面做添加日志方法的操作，但是如果这类不是你写的，代码量有比较多，万一添加后代码蹦了呢，其次这也不满足开闭原则。因为改动了原由代码。

public class UserServiceImp implements UserService{
    @Override
    public void add() {
        System.out.println("日志记录了添加方法");
        System.out.println("执行的添加方法");
    }
    @Override
    public void select() {
        System.out.println("日志记录了查询方法");
        System.out.println("执行的查询方法");
    }
    @Override
    public void delect() {
        System.out.println("日志记录了删除方法");
        System.out.println("执行的删除方法");
    }
}

这样做肯定是不行的，这时我们就可以采用代理模式来做 新增一个代理类也去实现UserService

public class UserServiceProxy implements UserService {
    private UserServiceImp userServiceImp;

    public void setUserServiceImp(UserServiceImp userServiceImp) {
        this.userServiceImp = userServiceImp;
    }
    @Override
    public void add() {
        log();
        userServiceImp.add();
    }
    @Override
    public void select() {
        log();
        userServiceImp.select();
    }
    @Override
    public void delect() {
        log();
        userServiceImp.select();
    }
    //日志方法
    public void log(){
        System.out.println("打印了日志");
    }
}

class Test{
    public static void main(String[] args) {
        UserServiceImp userServiceImp = new UserServiceImp();
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserServiceImp(userServiceImp);;
        userServiceProxy.add();
    }

}

这样子我们可以为想要的UserServiceImp 方法添加日志，即没有修改原由代码，这样子符合开闭原则

在Java中线程的设计就使用了静态代理设计模式，其中自定义线程类实现Runable接口，Thread类也实现了Runalbe接口，在创建子线程的时候，传入了自定义线程类的引用，再通过调用start()方法，调用自定义线程对象的run()方法。实现了线程的并发执行。

public class Test2 {
     public static void main(String[] args) {
          //Runnable实现类对象，真实角色
          Thread1 role1 = new Thread1();
          //线程类代理角色，该类也实现了Runnable接口，代理角色
          Thread thread1 = new Thread(role1);//传入了真实角色的引用      
          thread1.start();  
     }
 }
 
class Thread1 implements Runnable {
     @Override
     public void run() {
         //TODO
     }
 }