精华内容
下载资源
问答
  • 静态代理代理模式实现方式之一,比较简单,主要分为三个角色:客户端,代理类,目标类;而代理类需要与目标类实现同一个接口,并在内部维护目标类的引用,进而执行目标类的接口方法,并实现在不改变目标类的情况下...

    在这里插入图片描述

    前言

    近期在研究Hook技术,需要用到动态代理,说到动态代理就会聊到它的兄弟静态代理,那它们到底是怎么一回事呢?实现方式有哪些呢?一起来看下

    代理模式

    代理在我们生活中随处可见,比如我们生活中的各种中介公司,以买一辆二手车为例:如果我买车,我可以自己去网上找车源,然后做质量检测,车辆过户等一系列的流程,但是这太费时间和精力了,我就是想花钱买个车而已,最后我居然吭哧吭哧的干了这么多活;于是我可以通过中介买车,我只用给钱,选车就行了,其它活都交给中介干,这就是代理的一种实现;还有网络代理(不管是正向还是反向代理),房屋租赁公司等都是代理的具体实现
    在Java编程里就有一种设计模式,即代理模式,提供了一种对目标对象的访问方式,即通过代理对象访问目标对象,代理对象是指具有与被代理对象相同的接口的类,客户端必须通过代理对象与被代理的目标类进行交互

    为啥使用代理模式:

    • 中间隔离:某些情况下,客户端不想或者不能直接引用一个目标对象,而代理类可以在客户端和目标类之前起到中介作用
    • 开闭原则,扩展功能:代理类除了是客户类和目标类的中介,还可以通过给代理类增加额外的功能来扩展目标类的功能,这样我们只需要修改代理类而不需要再修改目标类,
      符合代码设计的开闭原则(对扩展开放,对修改关闭)。代理类主要负责为目标类预处理消息、过滤消息、把消息转发给目标类,以及事后对返回结果的处理等。
      代理类本身并不真正实现服务,而是同过调用目标类的相关方法,来提供特定的服务。真正的业务功能还是由目标类来实现,但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能,我们就可以使用代理类来完成,而没必要打开已经封装好的目标类。

    代理实现方式:
    如果按照代理创建的时期来进行分类的话, 可以分为静态代理、动态代理

    • 静态代理是由程序员创建或特定工具自动生成代理类,再对其编译,在程序运行之前,代理类.class文件就已经被创建了
    • 动态代理是在程序运行时通过反射机制动态创建代理对象

    如图:
    在这里插入图片描述

    开源框架应用:
    Spring框架是时下很流行的Java开源框架,Spring之所有如此流行,跟它自身的特性是分不开的,一个是IOC,一个是AOP

    • IOC是Inverse Of Control,即控制反转,也有人把IOC称作依赖注入。我觉得依赖注入这种说法很好理解,但不完全对;依赖注入是Dependency Injection的缩写,是实现IOC的一种方法,但不等同于IOC,IOC是一种思想,DI只是一种实现

    • AOP是Aspect Oriented Programming的缩写,即面向切面编程;与面向过程和面向对象的编程方式相比,面向切面编程提供了一种全新的思路,解决了OOP编程过程中的一些痛点。

    • IOC的实现原理是利用了JAVA的反射技术,那么AOP的实现原理是什么呢?就是动态代理技术,目前动态代理技术主要分为Java自己提供的JDK动态代理技术和CGLIB技术

    AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

    Retrofit框架应该是时下Android端最流行的网络访问框架了,而动态代理技术在里面就运用的非常多,对接口进行解析,获取到接口里的注解信息,参数等,然后封装成Http请求,最后再由底层网络请求框架OKHttp执行

    静态代理

    静态代理是代理模式实现方式之一,比较简单,主要分为三个角色:客户端,代理类,目标类;而代理类需要与目标类实现同一个接口,并在内部维护目标类的引用,进而执行目标类的接口方法,并实现在不改变目标类的情况下前拦截,后拦截等所需的业务功能。

    假设现在项目经理给你提了一个需求:在项目所有类的有关用户操作的方法前后打印日志;这种情况下就可以通过静态代理实现

    做法就是:为每个相关类都编写一个代理类(业务重合的可以共用一个代理类),并且让它们实现相同的接口

    定义接口:

    public interface ILogin {
        void userLogin();
    }
    

    定义目标类:

    public class UserLogin implements ILogin {
    
        @Override
        public void userLogin() {
            System.out.print("用户登录");
        }
    }
    

    定义代理类:

    public class UserLoginProxy implements ILogin {
    
        private UserLogin mLogin;
        public UserLoginProxy() {
            mLogin = new UserLogin();
        }
    
        @Override
        public void userLogin() {
            System.out.print("登录前。。。");
            mLogin.userLogin();
            System.out.print("登录后。。。");
        }
    }
    

    客户端:

    public class Test {
        public static void main(String[] args){
            ILogin loginProxy = new UserLoginProxy();
            loginProxy.userLogin();
        }
    }
    

    这样我们就在尽量不修改现有类的基础上实现了这个需求,同时客户端只用跟代理类打交道,完全不用了解代理类与目标类的实现细节,也不需要知道目标类是谁;当然你如果想指定目标类,将在外部创建目标类,传给代理类
    这里只是在同步情况下的一种实现,如果是异步操作,就需要进行一些改动

    静态代理总结:

    • 优点:在符合开闭原则的情况下,对目标对象功能进行扩展和拦截
    • 缺点:需要为每个目标类创建代理类和接口,导致类的数量大大增加,工作量大;接口功能一旦修改,代理类和目标类也得相应修改,不易维护

    动态代理

    从静态代理的实现过程可以知道工作量太大,如果是在项目早期同步做还好,要是在接手老项目或者项目晚期再做,你可能要为成百上千个类创建对应的代理对象,那真的挺让人崩溃的;所以我们就需要想有没有别的方法:如何少写或者不写代理类却能完成这些功能

    做Java的都知道一个.java文件会先被编译成.class文件,然后被类加载器加载到JVM的方法区,存在形式是一个Class对象(所谓的Class对象就是Class文件在内存中的实例);我们构造出的任何对象实例是保存在Heap中,而实例是由其Class对象创建的(可以通过任意实例的getClass方法获取对应的Class对象),比如平时使用new关键字加构造方法Person p = new Person()就是将这个Class对象在Heap中创建一个实例;可以看出要创建一个实例,最关键的是得到对应的Class对象,而得到Class对象追根溯源需要一个Java文件;那么我们要做的就是不写Java文件,而是直接得到代理Class对象,然后根据它通过反射创建代理实例

    Class对象里面包含了一个类的所有信息,比如构造器,方法,字段等;那我们怎么在不写代理类的前提下获取到这些信息呢?从静态代理的实现知道目标类和代理类实现了同一个接口,这是为了尽可能保证代理对象的内部结构和目标对象一致,这样代理对象只需要专注于代码增强部分的编写,所以接口拥有代理对象和目标对象共同的类信息,那么我们就可以从接口获取本来应该由代理类提供的信息,但是要命的是接口是不能实例化的啊

    这就要讲到动态代理了:在动态代理中,不需要我们再手动创建代理类,只需要编写一个动态处理器及指定要代理的目标对象实现的接口,真正的代理对象由JDK在运行时为我们创建;JDK提供了java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy来实现动态代理

    JDK代理

    Proxy.getProxyClass(ClassLoader, interfaces)方法只需要接收一个类加载器和一组接口就可以返回一个代理Class对象,然后就可以通过反射创建代理实例;其原理就是从传入的接口Class中,拷贝类结构信息到一个新的Class对象中,并继承Proxy类,拥有构造方法;站在我们的角度就是通过接口Class对象创建代理类Class对象

    这里通过一个很骚的比喻来说明下:一个东厂太监(接口Class对象)有一家子财产,但是为了侍奉皇帝这一伟大事业,毅然决然的割了DD(没有构造方法),虽然实现了自己的理想,但是不能繁育下一代(不能构造器创建对象),也就没有后人继承自己的家业;但是好在华佗在世,江湖上有一个高人(Proxy),发明了一个克隆大法(getProxyClass),不仅克隆出了几乎和太监一样的下一代(新的Class),还拥有自己的小DD(构造方法),这样这个下一代就能继承太监的家产(类结构信息,其实是实现了该接口),同时还能娶妻生子,传给下一代(创建实例)

    用一副图展示动态代理和静态代理实现思路:

    在这里插入图片描述

    那这样就很简单了

        public static Object loadProxy(Object target) throws Exception {
            //通过接口Class对象创建代理Class对象
            Class<?> proxyClass = Proxy.getProxyClass(target.getClass().getClassLoader(), target.getClass().getInterfaces());
            //拿到代理Class对象的有参构造方法
            Constructor<?> constructors = proxyClass.getConstructor(InvocationHandler.class);
            //反射创建代理实例
            Object proxy = constructors.newInstance(new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("执行前日志..."+"\n");
                    //执行目标类的方法
                    Object result = method.invoke(target, args);
                    System.out.println("执行后日志..."+"\n");
                    return result;
                }
            });
            return proxy;
        }
        
        public static void main(String[] args) throws Exception {
            ILogin proxy = (ILogin) loadProxy(new UserLogin());
            proxy.userLogin();
        }
    

    看看打印结果
    在这里插入图片描述
    这样无论系统有多少目标类,通过传进来的目标类都可以获取到对应的代理对象,就达到我们在执行目标类前后加日志的效果了,同时还不需要编写代理类

    Proxy类还有个更简单的方法newProxyInstance,直接返回代理对象,如下

        public static Object loadProxy(Object object) {
            return Proxy.newProxyInstance(
                    object.getClass().getClassLoader(), //和目标对象的类加载器保持一致
                    object.getClass().getInterfaces(), //目标对象实现的接口,因为需要根据接口动态生成代理对象
                    new InvocationHandler() { //事件处理器,即对目标对象方法的执行
    
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            System.out.println("执行前日志...");
    
                            Object result = method.invoke(object, args);
    
                            System.out.println("执行后日志...");
                            return result;
                        }
                    });
        }
    

    JDK动态代理总结:

    • 优点:相对于静态代理,极大的减少类的数量,降低工作量,减少对业务接口的依赖,降低耦合,便于后期维护;同时在某些情况下是最大的优势,即可以统一修改代理类的方法逻辑,而不需要像静态代理需要修改每个代理类
    • 缺点:因为使用的是反射,所以在运行时会消耗一定的性能;同时JDK代理只支持interface的动态代理,如果你再继续深究源码,会发现,所有动态生成的代理对象都有一个共同的父类,即都继承于Proxy;Java的单继承机制决定了无法支持class的动态代理,也就意味着你拿到动态生成的代理对象,只能调用其实现的接口里的方法,无法像静态代理中的代理类可以在内部扩展更多的功能

    动态生成代理对象原理

    在动态代理的过程中,我们不能清晰的看到代理类的实际样子,而且被代理对象和代理对象是通过InvocationHandler来完成的代理过程,其中代理对象是如何生成的,具体什么样,为什么代理对象执行的方法都会走到InvocationHandler中的invoke方法,要想了解这些就需要对Java是如何动态生成代理对象源码进行分析,继续往下看

    在这里插入图片描述
    你们有没有好奇getProxyClass这个方法是怎么通过【目标类实现的接口】生成代理Class对象的呢?

    如果你在第一个方法输入如下代码

    System.out.println("执行日志..."+(proxy instanceof Proxy)+"\n");
    System.out.println("执行日志..."+(proxyClass.getName())+"\n");
    System.out.println("执行日志..."+(proxyClass.getSuperclass().getName())+"\n");
    System.out.println("执行日志..."+(proxyClass.getSuperclass().getSimpleName())+"\n");
    System.out.println("执行日志..."+(proxyClass.getInterfaces()[0].getSimpleName())+"\n");
    

    得到的结果是
    在这里插入图片描述

    • 第一个结果为true,说明代理对象属于Proxy类型
    • 第二个结果是代理对象的全限定类名
    • 第三个结果是代理对象的父类的全限定名,第四个结果是父类名
    • 第四个结果是代理对象实现的接口名

    从这四点是不是能知道点啥了:动态生成的代理对象的父类是Proxy,实现了ILogin接口;这也就是为什么能将代理对象强转成ILogin,从而调用其接口方法;也说明了为什么只能支持动态生成接口代理,不能动态生成class代理,因为最终生成的代理对象肯定会继承Proxy类,如果我们提供的类已经继承了其它类,那就不能继承Proxy类了,动态代理也就无从谈起了

    接下来再从源码分析下其原理,鉴于篇幅原因,这里只分析重点代码

    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
            proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
     /**
     * 如果存在实现给定接口的给定加载器定义的代理类,则只返回缓存副本; 否则,它将通过ProxyClassFactory创建代理类
     */
     private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {
         if (interfaces.length > 65535) {
             throw new IllegalArgumentException("interface limit exceeded");	
         }
         return proxyClassCache.get(loader, interfaces);
     }
        
    private static final class ProxyClassFactory
            implements BiFunction<ClassLoader, Class<?>[], Class<?>>
        {
            // 所有代理类名称的前缀
            private static final String proxyClassNamePrefix = "$Proxy";
    
            // 用于生成唯一代理类名称的下一个数字
            private static final AtomicLong nextUniqueNumber = new AtomicLong();
    
            @Override
            public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    
                Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
                for (Class<?> intf : interfaces) {//通过传入的接口clone后的接口
    
                ......
    
                String proxyPkg = null;     // 定义代理class的包名
                int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
    
    
                for (Class<?> intf : interfaces) {
                    int flags = intf.getModifiers();//获取接口修饰符
                    if (!Modifier.isPublic(flags)) {//我们定义的接口修饰符都是public,所以这里不会进去
                        accessFlags = Modifier.FINAL;
                        String name = intf.getName();
                        int n = name.lastIndexOf('.');
                        String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                        if (proxyPkg == null) {
                            proxyPkg = pkg;
                        } else if (!pkg.equals(proxyPkg)) {
                            throw new IllegalArgumentException(
                                "non-public interfaces from different packages");
                        }
                    }
                }
    
                if (proxyPkg == null) {
                    // 如果没有非public代理接口,请使用com.sun.proxy包
                    proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
                }
    
                /*
                 * 生成代理class名称
                 * 比如com.sun.proxy.$Proxy0
                 */
                long num = nextUniqueNumber.getAndIncrement();
                String proxyName = proxyPkg + proxyClassNamePrefix + num;
    
                /*
                 * 通过接口和class名称生成代理class数据
                 * 如果继续看generateProxyClass,会发现里面是生成class数据,包括写入Object的三个初始方法、写入实现的接口、写入继承Proxy类等到ByteArrayOutputStream中,然后转换成byte数组返回,至于是否会将Byte数据写到class文件保存在本地,视情况而定(默认不保存到硬盘)   
                 */
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces, accessFlags);
                try {
                    //将动态生成的class数据加载到内存中 生成一个代理class对象
                    return defineClass0(loader, proxyName,
                                        proxyClassFile, 0, proxyClassFile.length);
                } catch (ClassFormatError e) {
                    throw new IllegalArgumentException(e.toString());
                }
            }
        }
    

    生成class数据源码

    ProxyGenerator.generateProxyClass()方法属于sun.misc包下,Oracle并没有提供源代码,但是我们可以使用JD-GUI这样的反编译软件打开jre\lib\rt.jar来一探究竟,以下是其核心代码的分析:

    
    public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
            ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
            final byte[] var4 = var3.generateClassFile();
            //是否将生成的class数据保存到硬盘,默认不保存
            if (saveGeneratedFiles) {
                ......
            }
            return var4;
        }
        
    private byte[] generateClassFile() {
            //添加hashCode方法
            this.addProxyMethod(hashCodeMethod, Object.class);
            //添加equals方法
            this.addProxyMethod(equalsMethod, Object.class);
            //添加toString方法
            this.addProxyMethod(toStringMethod, Object.class);
            Class[] var1 = this.interfaces;
            int var2 = var1.length;
    
            int var3;
            Class var4;
            //遍历接口数组
            for(var3 = 0; var3 < var2; ++var3) {
                var4 = var1[var3];
                Method[] var5 = var4.getMethods();
                int var6 = var5.length;
                //添加接口里的方法,此时方法体还为空
                for(int var7 = 0; var7 < var6; ++var7) {
                    Method var8 = var5[var7];
                    this.addProxyMethod(var8, var4);
                }
            }
    
            Iterator var11 = this.proxyMethods.values().iterator();
    
            List var12;
            while(var11.hasNext()) {
                var12 = (List)var11.next();
                checkReturnTypes(var12);
            }
    
            Iterator var15;
            try {
                //添加一个带有InvocationHandler的构造方法
                this.methods.add(this.generateConstructor());
                var11 = this.proxyMethods.values().iterator();
                //生成方法体代码
                while(var11.hasNext()) {
                    var12 = (List)var11.next();
                    var15 = var12.iterator();
    
                    while(var15.hasNext()) {
                        ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
                        this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
                        //方法体里生成调用InvocationHandler的invoke方法代码
                        this.methods.add(var16.generateMethod());
                    }
                }
    
                this.methods.add(this.generateStaticInitializer());
            } catch (IOException var10) {
                throw new InternalError("unexpected I/O Exception", var10);
            }
    
            if (this.methods.size() > 65535) {
                throw new IllegalArgumentException("method limit exceeded");
            } else if (this.fields.size() > 65535) {
                throw new IllegalArgumentException("field limit exceeded");
            } else {
                this.cp.getClass(dotToSlash(this.className));
                this.cp.getClass("java/lang/reflect/Proxy");
                var1 = this.interfaces;
                var2 = var1.length;
                //生成实现接口,继承Proxy类代码
                for(var3 = 0; var3 < var2; ++var3) {
                    var4 = var1[var3];
                    this.cp.getClass(dotToSlash(var4.getName()));
                }
    
                this.cp.setReadOnly();
                ByteArrayOutputStream var13 = new ByteArrayOutputStream();
                DataOutputStream var14 = new DataOutputStream(var13);
    
                try {
                    var14.writeInt(-889275714);
                    var14.writeShort(0);
                    var14.writeShort(49);
                    this.cp.write(var14);
                    var14.writeShort(this.accessFlags);
                    var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
                    var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
                    var14.writeShort(this.interfaces.length);
                    Class[] var17 = this.interfaces;
                    int var18 = var17.length;
    
                    for(int var19 = 0; var19 < var18; ++var19) {
                        Class var22 = var17[var19];
                        var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
                    }
    
                    var14.writeShort(this.fields.size());
                    var15 = this.fields.iterator();
    
                    while(var15.hasNext()) {
                        ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
                        var20.write(var14);
                    }
    
                    var14.writeShort(this.methods.size());
                    var15 = this.methods.iterator();
    
                    while(var15.hasNext()) {
                        ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
                        var21.write(var14);
                    }
    
                    var14.writeShort(0);
                    return var13.toByteArray();
                } catch (IOException var9) {
                    throw new InternalError("unexpected I/O Exception", var9);
                }
            }
        }
    

    从源码可以得出:

    • JDK帮我们生成了这样一个class数据,它继承了Proxy类,添加了一个带InvocationHandler参数的构造方法,这样也就明白了为什么使用构造方法反射创建代理对象的时候传入了一个InvocationHandler参数,因为默认会调用到Proxy类的构造方法,其参数正好是InvocationHandler,赋值给内部的成员变量h
      protected Proxy(InvocationHandler h) {
          Objects.requireNonNull(h);
          this.h = h;
      }
      
    • 实现了我们指定的接口,并实现了接口里的方法,同时接口中的方法调用了InvocationHandler的invoke方法
    • 当代理对象执行方法的时候,方法里面都会执行InvocationHandler的invoke方法,我们就可以在这里执行目标类方法

    这样可以说动态生成代理class对象其实是动态生成代理class数据

    动态代理类真身

    使用如下代码将动态生成的class数据保存到硬盘

        public static void write(){
            byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", UserLogin.class.getInterfaces());
            String path = "D:/Workspaces/com/sun/proxy/LoginProxy.class";
            try(FileOutputStream fos = new FileOutputStream(path)) {
                fos.write(classFile);
                fos.flush();
                System.out.println("代理类class文件写入成功");
            } catch (Exception e) {
                System.out.println("写文件错误");
            }
        }
    

    接下来将这个class文件反编译成Java文件看看:如果你没有jad工具,可以通过JAD Java Decompiler下载,使用如下命令

    /**
    * -d :用户指定输出文件保存目录
    * d:\  :具体目录目录
    * -sjava :输出文件扩展名 这里保存成Java文件
    * D:\Workspaces\com\sun\proxy\LoginProxy.class :class文件
    */
    jad -d d:\ -sjava D:\Workspaces\com\sun\proxy\LoginProxy.class
    /**
    * 上面的命令没有指定保存的Java文件名,下面的命令可以指定保存文件名
    * -p 输出详细文件信息
    */
    jad -p D:\Workspaces\com\sun\proxy\LoginProxy.class > D:\Workspaces\com\sun\proxy\LoginProxy.java
    

    代理类:

    public final class $Proxy0 extends Proxy implements ILogin
    {
    
        public $Proxy0(InvocationHandler invocationhandler)
        {
            super(invocationhandler);
        }
    
        public final boolean equals(Object obj)
        {
            try
            {
                return ((Boolean)super.h.invoke(this, m1, new Object[] {
                    obj
                })).booleanValue();
            }
            catch(Error _ex) { }
            catch(Throwable throwable)
            {
                throw new UndeclaredThrowableException(throwable);
            }
        }
    
        public final String toString()
        {
            try
            {
                return (String)super.h.invoke(this, m2, null);
            }
            catch(Error _ex) { }
            catch(Throwable throwable)
            {
                throw new UndeclaredThrowableException(throwable);
            }
        }
    
        public final void userLogin()
        {
            try
            {
                super.h.invoke(this, m3, null);
                return;
            }
            catch(Error _ex) { }
            catch(Throwable throwable)
            {
                throw new UndeclaredThrowableException(throwable);
            }
        }
    
        public final int hashCode()
        {
            try
            {
                return ((Integer)super.h.invoke(this, m0, null)).intValue();
            }
            catch(Error _ex) { }
            catch(Throwable throwable)
            {
                throw new UndeclaredThrowableException(throwable);
            }
        }
    
        private static Method m1;
        private static Method m2;
        private static Method m3;
        private static Method m0;
    
        static 
        {
            try
            {
                m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                    Class.forName("java.lang.Object")
                });
                m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
                m3 = Class.forName("com.mango.demo.proxy.ILogin").getMethod("userLogin", new Class[0]);
                m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            }
            catch(NoSuchMethodException nosuchmethodexception)
            {
                throw new NoSuchMethodError(nosuchmethodexception.getMessage());
            }
            catch(ClassNotFoundException classnotfoundexception)
            {
                throw new NoClassDefFoundError(classnotfoundexception.getMessage());
            }
        }
    }
    
    • JDK为我们生成了一个$Proxy0(这个名字后面的0是编号,有多个代理类会一次递增)的代理类
    • 代理类实现了ILogin接口,继承了Proxy类,并有一个带InvocationHandler参数的构造方法,使用super调用Proxy类的构造方法,证实了上面的分析
    • 实现了接口的userLogin方法,并在其内部调用InvocationHandler的invoke方法,其h正是Proxy类定义的成员变量
    • 最下面是通过反射拿到类中的几个方法,作为参数传递到InvocationHandler.invoke方法中,即调用动态代理对象的任何方法,最终都是走到InvocationHandler.invoke方法中(所以在invoke方法中写日志需要判断下,是否是调用代理对象指定的方法走到这里)

    至此就解答了这一节【动态生成代理对象原理】刚开始提出的几个疑问了

    总结

    JDK动态代理是实现AOP编程的一种途径,可以在执行指定方法前后贴入自己的逻辑,像Spring、Struts2就有用到该技术(拦截器设计就是基于AOP的思想);只不过JDK动态代理只能实现基于接口的动态代理,也算是一个遗憾,还有这种实现方式也不能避免类数量增加,因为你必须要为每个业务类编写业务接口;那么有没有不用写代理类、也不用写业务接口的代理方法呢?

    方法是有的,需要用到CGLib了:

    CGLIB(Code Generation Library)是一个强大的,高性能,高质量的Code生成类库,它可以在运行期扩展Java类与实现Java接口
    CGLIB比JDK的代理更加强大,不只可以实现接口,还可以扩展类,通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势植入横切逻辑。但因为采用的是继承,所以不能对final修饰的类进行代理
    CGLIB底层封装了ASM,通过对字节码的操作来生成类,具有更高的性能,但是CGLIB创建代理对象时所花费的时间却比JDK多;ASM是一套JAVA字节码生成架构,能够动态生成.class文件并在加载进内存之前进行修改
    使用CGLIB需要引用jar包cglib-nodep-3.2.5.jar(如果引入cglib.jar,还需要引入asm的jar包)

    像Spring框架都支持这两种动态代理方式,但Spring默认使用JDK动态代理,在需要代理类而不是代理接口的时候,Spring会自动切换为使用CGLIB代理,不过现在的项目都是面向接口编程,所以JDK动态代理相对来说用的还是多一些。

    至于在我们自己的业务里需要选择哪种方式实现AOP,还是需要视情况而定,两种方式组合使用或许能支持更多的业务需求

    展开全文
  • 产品经理or项目经理

    千次阅读 2017-08-02 18:58:35
    首先在网络上看到一句话:每个人心中都有一个江湖,每个人对江湖...许多人在谈到产品经理与项目经理时候,都不会有特别清晰的区别,自从有了软件项目就有了项目经理,那么产品呢? 那我们分别用一句话来概括: 产...

    首先在网络上看到一句话:每个人心中都有一个江湖,每个人对江湖的理解也各不相同。有人的地方就有江湖,心有多大,江湖就有多大,江湖在我们每个人的心里。江湖是兴风血雨,江湖是儿女情长,江湖是风起云涌,江湖是马云、刘强东,江湖是我们实现抱负的地方,江湖在你我之间。

    许多人在谈到产品经理与项目经理时候,都不会有特别清晰的区别,自从有了软件项目就有了项目经理,那么产品呢?

    那我们分别用一句话来概括:

    产品经理:靠想,做正确的事情,其所领导的产品是否符合市场需求,能否给公司带来多大利润。

    项目经理:靠做,把事情做正确,把事情做完美,在时间,成本和资源约束条件下完成目标。

    再次,从管理角度,产品经理是横向的,项目经理是纵向的。

     

    产品经理关注的是做正确的事,关注的是产品生命周期,关注的是产品是否能够赚钱,能否持续的赚钱。因此产品经理必须要能够规划整个产品的架构和发展路线,能够确定产品的定位和受众,能够预计产品真正的价值和效益。

    项目经理是需要正确的做事情,即按照产品规划制定的项目目标正确的做事情。项目能够按照目标完成则项目就是成功的,如果项目的产品不能真正盈利往往则是产品规划出现了失误。


    产品经理关注的是做正确的事,关注的是产品生命周期,关注的是产品是否能够赚钱,能否持续的赚钱。因此产品经理必须要能够规划整个产品的架构和发展路线,能够确定产品的定位和受众,能够预计产品真正的价值和效益。

    项目经理是需要正确的做事情,即按照产品规划制定的项目目标正确的做事情。项目能够按照目标完成则项目就是成功的,如果项目的产品不能真正盈利往往则是产品规划出现了失误。

    例如我们姑且理解项目经理是一个开发部门的项目经理,那么他一定是对某个产品进行开发的管理,负责开发的进度,开发过程中的协调,供应链等有关开发方面的问题,他最大的目标是时间第一,立项目标达成第一。并不会很尊重产品本身的市场需求以及业务逻辑的问题。在一个公司中类似这样纵向管理的部门都是一个个职能部门,例如市场部,主要负责推广,销售部主要负责销售等,而产品经理是横向管理的,也就是说他将负责某个产品或者某个产品线从商业计划市场竞争开发需求推广方案渠道策略物流等各个方面。当然产品经理不一定是决策人,每个公司对产品经理的权限限制也不同,但是产品经理一个产品线从头到尾的重要参与人。

    想做好产品经理需要很多方面的才华和技能,他也是一个公司中最适合培养复合型人才潜力的职位。一个产品经理可能没有权利,但是一个产品经理要善于运用同事关系,客户关系去协调去促进事情的发展,一个项目是属于项目经理开发的,他有开发目标达成的责 任。而这个项目也是属于产品经理的,他有对商业计划负责的责任。因此作为产品经理就意味着的和本产品有关的事,不论是开发生产推广销售成本物流渠道都是你的问题!

    如果希望做一个复合人才就选择产品经理,如果希望做一个专注人才就选择项目经理。产品生命周期和项目生命周期产 品生命周期关注的是整个产品从规划到制造,再到最终维护和消亡的整个过程。一个产品往往会由多个项目来实现,也可能分多个迭代周期来实现。由于项目有特定 的目标,一般产品制造出来通过验收则项目生命周期就算完成。而产品生命周期则不同,既包括了项目开始前的预研,评估和可行性研究,也包括了项目完成后产品 的维护和废弃。产品管理和项目管理产品管理的目标是产品,是产品生命周期;而项目管理的是项目生命周期和项目目标的实现。

    产品管理关心的是产品能够真正的赚钱和创造效益,因此前期的项目分析决策,后期推广都很重要,跟产品管理相对应的是组合项目管理。IPD集成产品开发是产品管理常用的方法论,其中两个重点就是组合项目管理和研发流程管理。

    项目管理关注的是项目能够按照既定的目标顺利完成。产品究竟应该规划哪些Feature不是项目管理的事情,而是项目管理的范围输入。

    项目管理始终关注的是进度,质量,成本和范围四个要素,要把项目做好则首先需要保证过程的稳定性。

    在软件项目管理中需要综合考虑工程,项目管理和支持过程三个方面的内容,因此实施CMMI或其它一些敏捷的项目管理方法论是可以保证项目管理成果的重要方法项目经理与产品经理另一个重要区别是授权的范围不同项目经理一般是被授权的合同履约的负责人:项目合同是规定承、发包双方责、权、利具有法律约束力的契约文件,是处理双方关系的主要依据,也是市场经济条件下规范双方行为的准则。

    项目经理是公司在合同项目上的全权委托代理人,代表公司处理执行合同中的一切重大事宜,包括合同的实施、变更调整、违约处罚等,对执行合同负主要责任。当然,根据企业的不同,老板能否给予项目经理相应的授权是另一回事。产品经理的授权是保证流通链的畅通:产品经理保证其所负责的产品,从上游创意、研发开始,至采购、生产,到下游渠道、通路,直至终端用户的整个流通链的畅通,因此要求产品经理既要有产品知识,也要有市场意识,还要具备协调能力,例如:财务、售后、物流……但是,产品经理并无对外签订合同的授权。

     

    有些文字转自:http://www.woshipm.com/pmd/19282.html

     

    展开全文
  • Java代理

    千次阅读 2017-08-22 09:27:11
    参考: 说说 JAVA 代理模式 java静态代理和动态代理事例小张是一个普普通通的码农,每天勤勤恳恳地码代码。某天中午小张刚要去吃饭,一个电话...不过小张却没有答应客户的请求,而是让客户找产品经理小李沟通。是小张

    参考:
    说说 JAVA 代理模式
    java静态代理和动态代理

    事例

    小张是一个普普通通的码农,每天勤勤恳恳地码代码。某天中午小张刚要去吃饭,一个电话打到了他的手机上。“是XX公司的小张吗?我是YY公司的王AA”。“哦,是王总啊,有什么事情吗?”。沟通过后,小张弄明白了,原来客户有个需求,刚好负责这方面开发的是小张,客户就直接找到了他。不过小张却没有答应客户的请求,而是让客户找产品经理小李沟通。

    是小张着急去吃面而甩锅吗?并不是,只是为了使故事可以套到代理模式上。我们先看一下代理模式的定义: * 为其他对象提供一种代理,以控制对这个对象的访问。(Provide a surrogate or placeholder for another object to control access to it)

    对照定义,码农小张可以映射为其他对象,产品经理小李为小张的代理。我们通过JAVA代码,表述上面事例。

    静态代理

    1.抽象角色

    基于面向对象的思想,首先定义一个码农接口,它有一个实现用户需求的方法。

    public interface ICoder {
    
        public void implDemands(String demandName);
    
    }

    2.真实角色

    我们假设小张是JAVA程序员,定义一个JAVA码农类,他通过JAA语言实现需求。

    public class JavaCoder implements ICoder{
    
        private String name;
    
        public JavaCoder(String name){
            this.name = name;
        }
    
        @Override
        public void implDemands(String demandName) {
            System.out.println(name + " implemented demand:" + demandName + " in JAVA!");
        }
    }

    3.代理角色

    委屈一下产品经理,将其命名为码农代理类,同时让他实现ICoder接口。

    public class CoderProxy implements ICoder{
    
        private ICoder coder;
    
        public CoderProxy(ICoder coder){
            this.coder = coder;
        }
    
        @Override
        public void implDemands(String demandName) {
            coder.implDemands(demandName);
        }
    }

    上面一个接口,两个类,就实现了代理模式。Are you kidding me?这么简单?是的,就是这么简单。 我们通过一个场景类,模拟用户找产品经理增加需求。

    public class Customer {
    
        public static void main(String args[]){
            //定义一个java码农
            ICoder coder = new JavaCoder("Zhang");
            //定义一个产品经理
            ICoder proxy = new CoderProxy(coder);
            //让产品经理实现一个需求
            proxy.implDemands();
        }
    }

    运行程序,结果如下:

    Zhang implemented demand:Add user manageMent in JAVA!

    产品经理充当了程序员的代理,客户把需求告诉产品经理,并不需要和程序员接触。看到这里,有些机智的程序员发现了问题。你看,产品经理就把客户的需求转达了一下,怪不得我看产品经理这么不爽。

    产品经理当然不只是转达用户需求,他还有很多事情可以做。比如,该项目决定不接受新增功能的需求了,对修CoderProxy类做一些修改:

    public class CoderProxy implements ICoder{
    
        private ICoder coder;
    
        public CoderProxy(ICoder coder){
            this.coder = coder;
        }
    
        @Override
        public void implDemands(String demandName) {
            if(demandName.startsWith("Add")){
                System.out.println("No longer receive 'Add' demand");
                return;
            }
            coder.implDemands(demandName);
        }
    }

    这样,当客户再有增加功能的需求时,产品经理就直接回绝了,程序员无需再对这部分需求做过滤。

    总结

    我们对上面的事例做一个简单的抽象:

    java代理

    代理模式包含如下角色:

    • Subject:抽象主题角色。可以是接口,也可以是抽象类。
    • RealSubject:真实主题角色。业务逻辑的具体执行者。
    • ProxySubject:代理主题角色。内部含有RealSubject的引用,负责对真实角色的调用,并在真实主题角色处理前后做预处理和善后工作。

    代理模式优点

    • 职责清晰 真实角色只需关注业务逻辑的实现,非业务逻辑部分,后期通过代理类完成即可。
    • 高扩展性 不管真实角色如何变化,由于接口是固定的,代理类无需做任何改动。

    静态代理类优缺点

    优点:业务类只需要关注业务逻辑本身,保证了业务类的重用性。这是代理的共有优点。

    缺点:

    1)代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理,静态代理在程序规模稍大时就无法胜任了。
    
    2)如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。
    

    另外,如果要按照上述的方法使用代理模式,那么真实角色(委托类)必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个代理角色,如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色(委托类),该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。

    动态代理

    前面讲的主要是静态代理。那么什么是动态代理呢?

    假设有这么一个需求,在方法执行前和执行完成后,打印系统时间。这很简单嘛,非业务逻辑,只要在代理类调用真实角色的方法前、后输出时间就可以了。像上例,只有一个implDemands方法,这样实现没有问题。但如果真实角色有10个方法,那么我们要写10遍完全相同的代码。有点追求的码农,肯定会对这种方法感到非常不爽。有些机智的小伙伴可能想到了用AOP解决这个问题。非常正确。莫非AOP和动态代理有什么关系?没错!AOP用的恰恰是动态代理。

    代理类在程序运行时创建的代理方式被称为动态代理。也就是说,代理类并不需要在Java代码中定义,而是在运行时动态生成的。相比于静态代理, 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理,而不用修改每个代理类的函数。对于上例打印时间的需求,通过使用动态代理,我们可以做一个“统一指示”,对所有代理类的方法进行统一处理,而不用逐一修改每个方法。下面我们来具体介绍下如何使用动态代理方式实现我们的需求。

    与静态代理相比,抽象角色、真实角色都没有变化。变化的只有代理类。因此,抽象角色、真实角色,参考ICoder和JavaCodr。

    在使用动态代理时,我们需要定义一个位于代理类与委托类之间的中介类,也叫动态代理类,这个类被要求实现InvocationHandler接口:

    public class CoderDynamicProxy implements InvocationHandler{
         //被代理的实例
        private ICoder coder;
    
        public CoderDynamicProxy(ICoder _coder){
            this.coder = _coder;
        }
    
        //调用被代理的方法
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println(System.currentTimeMillis());
            Object result = method.invoke(coder, args);
            System.out.println(System.currentTimeMillis());
            return result;
        }
    }

    当我们调用代理类对象的方法时,这个“调用”会转送到中介类的invoke方法中,参数method标识了我们具体调用的是代理类的哪个方法,args为这个方法的参数。

    我们通过一个场景类,模拟用户找产品经理更改需求。

    public class DynamicClient {
    
         public static void main(String args[]){
                //要代理的真实对象
                ICoder coder = new JavaCoder("Zhang");
                //创建中介类实例
                InvocationHandler  handler = new CoderDynamicProxy(coder);
                //获取类加载器
                ClassLoader cl = coder.getClass().getClassLoader();
                //动态产生一个代理类
                ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
                //通过代理类,执行doSomething方法;
                proxy.implDemands("Modify user management");
            }
    }

    执行结果如下:

    1501728574978
    Zhang implemented demand:Modify user management in JAVA!
    1501728574979

    通过上述代码,就实现了,在执行委托类的所有方法前、后打印时间。还是那个熟悉的小张,但我们并没有创建代理类,也没有时间ICoder接口。这就是动态代理。

    总结

    总结一下,一个典型的动态代理可分为以下四个步骤:

    1. 创建抽象角色
    2. 创建真实角色
    3. 通过实现InvocationHandler接口创建中介类
    4. 通过场景类,动态生成代理类

    如果只是想用动态代理,看到这里就够了。但如果想知道为什么通过proxy对象,就能够执行中介类的invoke方法,以及生成的proxy对象是什么样的,可以继续往下看。

    源码分析(JDK7)

    看到这里的小伙伴,都是有追求的程序员。上面的场景类中,通过

    //动态产生一个代理类
    ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
    

    动态产生了一个代理类。那么这个代理类是如何产生的呢?我们通过代码一窥究竟。

    Proxy类的newProxyInstance方法,主要业务逻辑如下:

    //生成代理类class,并加载到jvm中
    Class<?> cl = getProxyClass0(loader, interfaces);
    //获取代理类参数为InvocationHandler的构造函数
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    //生成代理类,并返回
    return newInstance(cons, ih);
    

    上面代码做了三件事:

    • 根据传入的参数interfaces动态生成一个类,它实现interfaces中的接口,该例中即ICoder接口的implDemands方法。假设动态生成的类为$Proxy0。
    • 通过传入的classloder,将刚生成的$Proxy0类加载到jvm中。
    • 利用中介类,调用Proxy0Proxy0(InvocationHandler)构造函数,创建$Proxy0类的实例,其InvocationHandler属性,为我们创建的中介类。

    上面的核心,就在于getProxyClass0方法:

    private static Class<?> getProxyClass0(ClassLoader loader,
                                               Class<?>... interfaces) {
            if (interfaces.length > 65535) {
                throw new IllegalArgumentException("interface limit exceeded");
            }
    
        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }
    

    在Proxy类中有个属性proxyClassCache,这是一个WeakCache类型的静态变量。它指示了类加载器和代理类之间的映射。所以proxyClassCache的get方法用于根据类加载器来获取Proxy类,如果已经存在则直接从cache中返回,如果没有则创建一个映射并更新cache表。

    我们跟一下代理类的创建流程:
    调用Factory类的get方法,而它又调用了ProxyClassFactory类的apply方法,最终找到下面一行代码:

    //Generate the specified proxy class.
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
    

    就是它,生成了代理类。

    查看动态生成的代理类

    通过上面的分析,我们已经知道Proxy类动态创建代理类的流程。那创建出来的代理类到底是什么样子的呢?我们可以通过下面的代码,手动生成:

    public class CodeUtil {
    
           public static void main(String[] args) throws IOException {
                byte[] classFile = ProxyGenerator.generateProxyClass("TestProxyGen", JavaCoder.class.getInterfaces());
                File file = new File("D:/aaa/TestProxyGen.class");
                FileOutputStream fos = new FileOutputStream(file);
                fos.write(classFile);
                fos.flush();
                fos.close();
              }
     }
    

    通过反编译工具查看生成的class文件:

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    import model.proxy.ICoder;
    
    public final class TestProxyGen extends Proxy
      implements ICoder
    {
      private static Method m1;
      private static Method m0;
      private static Method m3;
      private static Method m2;
    
      public TestProxyGen(InvocationHandler paramInvocationHandler)
        throws
      {
        super(paramInvocationHandler);
      }
    
      public final boolean equals(Object paramObject)
        throws
      {
        try
        {
          return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
        }
        catch (RuntimeException localRuntimeException)
        {
          throw localRuntimeException;
        }
        catch (Throwable localThrowable)
        {
        }
        throw new UndeclaredThrowableException(localThrowable);
      }
    
      public final int hashCode()
        throws
      {
        try
        {
          return ((Integer)this.h.invoke(this, m0, null)).intValue();
        }
        catch (RuntimeException localRuntimeException)
        {
          throw localRuntimeException;
        }
        catch (Throwable localThrowable)
        {
        }
        throw new UndeclaredThrowableException(localThrowable);
      }
    
      public final void implDemands(String paramString)
        throws
      {
        try
        {
          this.h.invoke(this, m3, new Object[] { paramString });
          return;
        }
        catch (RuntimeException localRuntimeException)
        {
          throw localRuntimeException;
        }
        catch (Throwable localThrowable)
        {
        }
        throw new UndeclaredThrowableException(localThrowable);
      }
    
      public final String toString()
        throws
      {
        try
        {
          return (String)this.h.invoke(this, m2, null);
        }
        catch (RuntimeException localRuntimeException)
        {
          throw localRuntimeException;
        }
        catch (Throwable localThrowable)
        {
        }
        throw new UndeclaredThrowableException(localThrowable);
      }
    
      static
      {
        try
        {
          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
          m3 = Class.forName("model.proxy.ICoder").getMethod("implDemands", new Class[] { Class.forName("java.lang.String") });
          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
          return;
        }
        catch (NoSuchMethodException localNoSuchMethodException)
        {
          throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException localClassNotFoundException)
        {
        }
        throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
      }
    }

    这样,我们就理解,为什么调用代理类的implDemands方法,会去执行中介类的invoke方法了。

    展开全文
  • 前言 有一天,小李在项目中发现一个严重的问题,需要直接向其他部门的经理B沟通该问题。... 这个例子中涉及到我们的代理模式,何为代理模式呢,从小李请求沟通这方面讲: 1、小李作为被领导A代理对象,...

    目录

    Java代理模式(1)一静态代理
    Java代理模式(2)一动态代理


    前言

    有一天,小李在项目中发现一个严重的问题,需要直接向其他部门的经理B沟通该问题。但是想来想去,出于职场经验小李决定不能直接去找那个经理,不能越过自己部门领导而直接去找。这样违反了职场规则。那么小李最后决定先找部门负责该项目的领导A,然后请求领导A向经理B反映沟通该问题。
    这个例子中涉及到我们的代理模式,何为代理模式呢,从小李请求沟通这方面讲:
    1、小李作为被领导A代理对象,他的所有问题都会反映给经理B。
    2、项目领导A,会代表小李把所有的问题反映给经理B
    3、小李与领导A都是一个同一部门的,都是为一个项目努力工作的。


    一、代理模式相关概念

    1、为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
    2、通过代理对象可以实现对委托对象(被代理对象)隐蔽与保护目的,同时因为实现了同一个接口的结果,代理类与被代理类实现了一致性。并且代理对象还可以进行灵活的扩展,不再害怕破坏原有功能模块。

    代理模式涉及三个角色信息:

    • 抽象角色:声明真实对象和代理对象的共同接,为了保持行为的一致性,代理类和委托类通常会实现相同的接口,所以在访问者看来两者没有丝毫的区别。
    • 代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
    • 真实角色:代理角色所代表的真实对象,是我们最终要引用的对象

    代理模式的UML图如下:
    这里写图片描述
    其中:

    • Subject方法是代理对象Proxy与真正被代理的对象RealSubject的共同接口
    • Proxy帮助对象代理RealSubject,在内部实现其RealSubject的方法Request(),包含了对RealSubject的引用。而在Proxy对象中客户不光只是简单调用RealSubject,还可能会涉及更多的实际业务操作,都可以在Proxy中扩展。

    二、代码举例实现

    以小李的问题举例简单实现Java代理模式

    Subject:小李与领导A共同重视的问题,都需要先去认识这个问题并一致提出解决方案

    /**
     * 领导A与小李都是所做的一切都是为了沟通解决问题的
     * @author Lijian
     *
     */
    public interface ProblemInterface {
        void resolve();//解决问题
    }

    RealSubject:小李有问题要反映,但是不能直接找经理B

    /**
     * 小李将问题都说领导A
     * @author Lijian
     *
     */
    public class RealSubject implements ProblemInterface{
    
        @Override
        public void resolve() {
            System.out.println("There is an fatal bug in xxx project, It mainly includes...");//小李有问题反映
        }
    }

    Proxy:领导A将小李反映的问题整理,然后做好沟通经理B的前后工作

    package proxy;
    
    /**
     * 领导A代理小李沟通解决问题
     * @author Lijian
     *
     */
    public class Proxy implements ProblemInterface{
        private ProblemInterface problemInterface = new RealSubject();//领导A已经与小李取得联系
        @Override
        public void resolve() {
            System.out.println("I'm preparing for it");//领导A先准备好材料
            problemInterface.resolve();//开始与经理B沟通反映
            System.out.println("In a word, I think the problem...");//结束后领导A做了总结
        }
    
    }
    

    Client:经理B也做好了与领导A的沟通准备,取得了领导A的联系

    /**
     * 经理B请求与领导A沟通一起解决问题
     * @author Lijian
     *
     */
    public class Client {
        public static void main(String[] args) {
            Proxy proxy = new Proxy();
            proxy.resolve();
        }
    }

    最后领导A顺利将问题反映给经理B,以下是A代理小李反映问题给经理B的过程:

    I'm preparing for it
    There is an fatal bug in xxx project, It mainly includes...
    In a word, I think the problem...
    

    以上就是其实就是Java三种模式(静态代理,动态代理,CGLib代理)中的静态代理。静态代理的缺点很明显:

    • 必须要通过开发人员手动去实现接口并调用的;
    • 只能一个代理类实现一个接口,如果接口中的还有未实现的方法时,代理类也要必须实现。同时会产生大量重复的代码。

    为此我们必须使用Java的另一种代理方式来进一步完善Java代理模式(2)一动态代理

    展开全文
  • 产品经理的私房菜 - 腾讯产品能力模型(序章)

    万次阅读 多人点赞 2021-04-16 18:41:49
    产品经理的私房菜 - 腾讯产品能力模型(序章) ❝ 编辑导语:为了解决”产品经理“职业成长中,不自信的问题。本系列就围绕”腾讯产品的能力模型“,一起从头梳理,每一个能力项的提升思路。希望大家从梳理过程中,...
  • 小张是一个普普通通的码农,每天勤勤恳恳地码代码。某天中午小张刚要去吃饭,一...不过小张却没有答应客户的请求,而是让客户找产品经理小李沟通。 是小张着急去吃面而甩锅吗?并不是,只是为了使故事可以套到代理模式
  • 产品经理——靠想。产品经理是做正确的事,其所领导的产品是否符合市场的需求,是否能给公司带来利润的。 项目经理——靠做。项目经理是把事情做正确,把事情作得完美,在时间,成本和资源约束的条件下完成目标。 ...
  • 产品经理广告位设计

    万次阅读 2019-05-25 14:58:21
    随着互联网的发展,产品经理岗位也出现了越来越细的分工,其中就出现了广告产品经理这一细分岗位。本文主要是结合笔者经验,从产品维度聊聊商业产品矩阵里的广告产品。 随着互联网的发展,曾经是万金油的产品经理...
  • 说说 JAVA 代理模式

    千次阅读 2018-06-17 18:49:57
    原文出处: 姜肇海 投稿事例小张是一个普普通通的码农,每天勤勤恳恳地码代码。...不过小张却没有答应客户的请求,而是让客户找产品经理小李沟通。是小张着急去吃面而甩锅吗?并不是,只是为了使...
  • 动态代理模式和责任链模式

    千次阅读 2017-10-21 15:22:34
    代理:即中介的意思,比如客户,公司产品经理,软件工程师之间的管理。产品经理代理者,软件工程师为被代理者。回到代码中,客户就是主程序,软件工程师就是切面程序
  • 有一句话说的很精辟:产品经理——靠想。产品经理是做正确的事,其所领导的产品是否符合市场的需求,是否能给公司带来利润的。项目经理——靠做。项目经理是把事情做正确,把事情作得完美,在时间,成本和资源约束的...
  • 产品经理和项目经理的区别

    千次阅读 2010-10-25 22:53:00
    产品经理和项目经理的区别
  • 这一点从项目经理在项目管理活动中的地位即可体现:项目经理是企业法定代表人在建设工程项目上的委托代理人,是对建设工程项目管理实施阶段全面负责的管理者。项目经理在整个建设活动中占有举足轻重的地位,那么如何...
  • 项目经理与产品经理的区别

    千次阅读 2012-06-01 19:06:39
    对两个PM的区别说得比较到位,所以转一下,欢迎认领。 有一句话说的很精辟: ...从管理的角度讲,项目经理是纵向的,而产品经理是横向的。 产品经理关注的是做正确的事,关注的是产品生命周期,关注的是
  • 敏捷项目经理 作为一名经理,当我第一次开始学习敏捷开发时,我对管理和 (或管理自己) 敏捷团队和项目的模糊方式感到困惑 ,并且对管理人员和管理人员的消极态度感到沮丧和失望。 调和项目管理和敏捷的尝试尚未...
  • Nginx玩法 — 反向代理

    千次阅读 2021-02-25 14:58:56
    Nginx反向代理简单入门
  • 对爬虫工作者来说,除了研究反爬虫策略、编写...假如三天两头出现问题,客户经理半天也不回复,那么还是自己选择他家。 第二,大量的资源。 有各地机房数万条独拨线路,资源丰富,为企业的大数据应用源源不断地输出新.
  • 代理模式之虚拟代理(仅了解)

    千次阅读 2016-03-28 17:26:39
    0.1)本文全文转自 “head first 设计模式”,旨在了解 虚拟代理+动态代理; 0.2)晚辈我 java.swing 烂到渣,没有写出干货荔枝,抱歉; 【1】虚拟代理简述 1)远程代理:作为另一个jvm上对象的本地代表; 2)...
  • 产品读书《人人都是产品经理 1.0》

    千次阅读 2018-08-07 17:09:50
    1 写给-1到3岁的产品经理 1.1 为什么要做产品经理 坏产品无处不在:垃圾桶、路标、盲道、洗手间的门、 好产品能改变世界:马桶 1.2 我们到底是不是产品经理 产品:用来解决某个问题的东西。...
  • 谈谈代理外国软件的事

    千次阅读 2017-08-15 09:53:42
    其实要代理一个歪果仁的软件,首先你得和对方正常的交流,这是基础,,有了基础,再得你的技术人员或者你能理解对方的产品使用文档甚至高级一点的二次开发文档,各种接口文档,API文档等,必要的时候还需要接受歪果...
  • 产品经理关注的是产品,也就是说他更关注的是产品是否符合市场需求,产品设计是否成功……,而项目经理关注的是项目,即如何做产品的过程,有个明确的目标,然后是利用资源完成目标。简单的说,产品经理关心在做产品...
  • 浅谈JAVA代理模式

    2017-09-28 11:28:53
    说说JAVA代理模式事例小张是一个普普通通的码农,每天勤勤恳恳地码代码。某天中午小张刚要去吃饭...不过小张却没有答应客户的请求,而是让客户找产品经理小李沟通。是小张着急去吃面而甩锅吗?并不是,只是为了使故事可
  • 代理模式

    千次阅读 2008-06-26 23:07:00
    在这些单位工作的人员均可称为代理人。代理人的共同特征是可以代替委托人去和第三方通信。譬如:律师代替委托人打官司,猎头代替委托人物色人才,红娘代替委托人寻找对象,房产代理人代替委托人出租房屋。代理人可以...
  • P2P行业产品经理的分析

    千次阅读 2015-04-07 11:30:18
    P2P行业产品经理的日常工作计划
  • 专利代理收入

    千次阅读 2018-12-31 17:48:43
    2016年全国专利代理人资格考试已拉开大幕,越来越多的人正在进入这个行业。随着我国专利申请量领跑全球和连续4年保持位居世界首位的惊人增速,“专利代理人”也越来越被更多的人所了解。在许多刚毕业的年轻人眼中,...
  • 解读项目经理在项目中的作用

    千次阅读 2020-05-04 07:30:20
    这个负责人就是项目经理,他是企业在项目上负责管理和履行承包合同的委托代理人。 项目经理是项目的现场管理最高负责人,在项目中占有举足轻重的地位。首先对企业外部,项目经理是企业法人代表在项目上的代理人。...
  • 了解你的客户(KYC)

    万次阅读 2018-10-10 15:21:21
    “了解你的客户”(KnowYou Customer,简称KYC,也称“尽职调查”、...要求对跨境代理银行业务及类似业务给予更加严格的审查。“了解你的客户”最早由巴塞尔银行监管委员会在《关于防止利用银行系统进行洗钱的声明》...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,706
精华内容 6,682
关键字:

代理客户经理