代理模式

代理

静态代理模式(只是一种理论指导，没有实际技术，技术看动态代理，使用了反射)
   ----为其它对象提供一个代理,以控制对当前对象的访问

核心思想：代理对象和被代理都实现同一个接口
    用户访问的时候先访问代理对象,然后让代理对象去访问被代理对象

项目中用法:
懒加载(没到达一定程度，不允许访问),
大对象(如果没有访问对象的属性，就给个假对象),
权限（，，，）

java.lang.reflect.Proxy: 代理类   ;   Proxy 是不可变对象

代理模式与适配器模式的区别：
代理模式更强，代理可以增加自己的功能！
适配器模式，只是调用！

静态代理代码：
        //然后代理类和被代理类都要实现这个接口,让他们有同样的行为
           public interface Meet {
            void meet(int money);
        }      

         //定义被代理对象刘德华,要实现会见接口,才能有会见功能
        public class Andy implements  Meet{
            @Override
            public void meet(int money) {
                System.out.println("你好 我是刘德华,很高兴见到你");
            }
        }

        /**
         * 定义一个刘德华代理类,实现会见接口
         */
        public class AndyProxy implements Meet {
            //要在代理类里面引用一个被代理类(刘德华)的实例
            private Andy andy = new Andy();

            @Override
            public void meet(int money) {
                //代理类要实现功能: 假设身价1000w以上才能见到刘德华,这个业务逻辑代理来处理
                if (money >= 1000) {
                    andy.meet( money );
                } else {
                    System.out.println( "不好意思,刘德华出差了,下次再会" );
                }

            }
        }
        
        
        
        
          //演示静态代理模式
        Meet meet=new AndyProxy();
        meet.meet( 1000 );
        
        
-------------------------

动态代理 (静态代理,上述原理一样； 核心区别在于代理对象；(动态使用了调用处理器,反射动态的生成代理对象)

Spring的核心思想，AOP面向切面编程思想也是使用动态代理！
          （AOP：在使用方法前做了些处理，调用方法后，又做了些处理）   ----》  遇到这种业务，考虑动态代理！！
事务底层实现也是AOP，AOP底层实现是动态代理！

        动态代理:         
                //定义被代理对象
                Eat eat = new Person();
                //生成调用处理器
                EatInvocationHandler h = new EatInvocationHandler(eat);
                //3.生成动态代理，必须传入类的Class接口
                Eat proxy = (Eat) Proxy.newProxyInstance(Person.class.getClassLoader(),Person.class.getInterfaces(), h);
                //调用动态代理
                proxy.eat();
                
                
        要执行的接口:
                public interface Eat {
                    void eat();
                }
                
        被代理对象要实现接口:
                public class Person implements  Eat{
                    @Override
                    public void eat() {
                        System.out.println("原始的饭");
                    }
                }
                
                
        调用处理器:
                public class EatInvocationHandler implements InvocationHandler {
                    private Object target;
                    public EatInvocationHandler(Object target){
                        this.target = target;
                    }
                    
                    //proxy: 返回代理对象
                    //method: 代理的方法
                    //args: 调用这个方法的传参
                    //target: 被代理的对象，由构造器传入
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("动态代理的操作,吃饭先洗手");
                        return method.invoke(target,args);
                    }
                }