静动态

角色分析：

- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真是角色，代理真实角色后，我们一般会做一些附属操作。
- 客户：访问代理对象的人！
```
//下面这个例子是静态
//接口
public interface UserService {
    //添加
    void add();
    //删除
    void delete();
    //修改
    void update();
    //查询
    void query();
}

//实现类 
public class UserServiceImpl implements  UserService {
    @Override
    public void add() {
        System.out.println("增加一个学生");
    }

    @Override
    public void delete() {
        System.out.println("删除一个学生");
    }

    @Override
    public void update() {
        System.out.println("修改一个学生");

    }

    @Override
    public void query() {
        System.out.println("查找一个学生");

    }
}

//增加一个类
public class UserServiceProxy implements UserService {
    private UserService userService;

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

    @Override
    public void add() {
        logger("增加");
        userService.add();
    }

    @Override
    public void delete() {
        logger("删除");
        userService.delete();
    }

    @Override
    public void update() {
        logger("修改");
        userService.update();
    }

    @Override
    public void query() {
        logger("查询");
        userService.query();
    }

    //日志
    public void logger(String msg){
        System.out.println("使用"+msg);
    }
}

//测试
public class Cilent {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl() ;
        UserServiceProxy u = new UserServiceProxy();
        u.setUserService(userService);
        u.delete();
    }
}

上面这个是静态代理,下面这个使用动态实现
----------------------------------------------------------------------------------
下面这个例子是动态代理实现

//接口
public interface UserService {
    //添加
    void add();
    //删除
    void delete();
    //修改
    void update();
    //查询
    void query();
}

//实现类
public class UserServiceImpl implements  UserService {
    @Override
    public void add() {
        System.out.println("增加一个学生");
    }

    @Override
    public void delete() {
        System.out.println("删除一个学生");
    }

    @Override
    public void update() {
        System.out.println("修改一个学生");

    }

    @Override
    public void query() {
        System.out.println("查找一个学生");

    }
}

//通过代理实现增加业务
public class ProxyInvocationHandler implements InvocationHandler {
    private Object targer;

    public void setTarger(Object targer){
        this.targer=targer;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                targer.getClass().getInterfaces(),
                this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        loogger(method.getName());
        Object result= method.invoke(targer, args);

        return result;
    }
    public void loogger(String msg){
        System.out.println("你使用了"+msg+"方法");
    }
}

--测试类


public class Client {
    public static void main(String[] args) {
           //真实角色
        UserServiceImpl userService = new UserServiceImpl();
          //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
         //通过调用程序处理角色来出来我们要调用的接口对象
        pih.setTarger(userService);
        UserService proxy = (UserService) pih.getProxy();
        proxy.delete();
    }
}

代理模式的好处：

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

缺点：

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