代理模式

代理模式就是新增长一个代理类，而后经过代理类来调用咱们的实现。

应用场景能够参考中介。

1.未使用代理类场景

        未使用代理类，即接口直接经过实现类实现功能

接口：

public interface UserDao {
    public void updateUser();
    public void delUser();
}

实现类：

public class UserDaoImpl implements UserDao{
    @Override
    public void updateUser() {
        System.out.println("更新用户成功");
    }

    @Override
    public void delUser() {
        System.out.println("删除用户成功");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        UserDao userDao=new UserDaoImpl();
        userDao.delUser();
        userDao.updateUser();
    }
}

2.使用代理类

2.1静态代理类

即新增一个代理类，来管理咱们的实现类，咱们能够在代理类中添加一些动做

将具体的实现经过构造器注入，而后代理类中调用咱们对应的实现类的方法，

新增的代理类以下：

public class StaticProxy implements UserDao{
    private UserDao userDao;
    public StaticProxy(UserDao userDao1)
    {
        this.userDao=userDao1;
    }


    @Override
    public void updateUser() {
        System.out.println("begin");
        userDao.updateUser();
        System.out.println("end ");
    }

    @Override
    public void delUser() {
        System.out.println("begin");
        userDao.delUser();
        System.out.println("end");
    }
}

测试类

public class ProxyTest {
    public static void main(String[] args) {
        UserDao userDaoProxy=new StaticProxy(new UserDaoImpl());
        userDaoProxy.delUser();
        userDaoProxy.updateUser();
    }
}

结果以下

2.2由静态代理类引出动态代理类

        能够看见，咱们的静态代理类也实现了UserDao接口，当接口新增内容时，如新增一个query()方法，此时，咱们的UserDaoImpl和StaticProxy类都要改变。

        这是咱们不想看见的，咱们但愿代理类能够不作修改，只须要修改咱们的实现类的内容。由此引出了动态代理类(由此动态代理类的做用也显而易见)

2.3动态代理类

定义动态代理工具类

返回指定的接口，将方法调用指定的调用处理程序的代理类的一个实例

三个参数能够查阅JDK明细，主要须要实现InvocationHandler接口，实现invoke方法，经过反射实现对抽象接口方法的调用method.invoke(target, args),调其中target就是咱们真正的实现类

-------------------------------------

public class DynamicProxy {
    public static void main(String[] args) {
        UserDao userDao = (UserDao) Proxy.newProxyInstance(
                UserDao.class.getClassLoader(),
                new Class[]{UserDao.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("proxy begin");
                        Object result = method.invoke(new UserDaoImpl(), args);
                        System.out.println("proxy end");
                        return result;
                    }
                }
        );
        userDao.delUser();
    }

两种写法都同样，上一种为lambda表达式，

输出结果

3.总结

代理模式强调一些通用功能的扩展，在方法执行前，执行后添加点什么东西(LOG)，静态即单一的扩展，动态为多个类扩展，可是都引入新的代理类，从性能上讲，新的代理类会致使性能有所降低