• java设计模式-代理模式


    代理模式是java最常见的设计模式之一。spring的aop就是使用了代理模式。

    一般而言,代理模式分为静态代理和动态代理两种。

    作为结构类的设计模式,作用在于不修改类内部代码的情况下,对类进行拓展,是对继承机制的一种补充。

    eg :下面就用户登录这个例子实现一下代理模式。

      基本需求是:实现用户的登录和修改昵称功能。

    上代码,先是IUser接口和user实现类

    public interface IUser {
        //登录
        void login(String userId,String password);
        //修改昵称
        void editNickname(String nickname);
    
    }
    public class User implements IUser {
        
        private String nickname;
        private String userId;
        private String password;
        
        public User(String userId,String password){
            this.userId = userId;
            this.password = password;
        }
    
        @Override
        public void login(String userId, String password){
            if(this.userId == userId && this.password == password){
                System.out.println("用户登录成功");
            }
            else
                System.out.println("用户登录失败");
        }
    
        @Override
        public void editNickname(String nickname) {
            this.nickname = nickname;
            System.out.println("修改昵称成功,当前用户的昵称是:"+this.nickname);
        }
    
    }

    客户端类

    public class Client {
        public static void main(String[] args) {
            //不调用代理模式时
            IUser user = new User("firs","123");
            user.login("firs", "123");
            user.editNickname("大风");
    }

    还是非常简单的。可是后面产品经理跟你说,我们需要增加一个记录用户行为的功能,这下该怎么办呢?直接修改user类?不不不,用代理模式。

    增加一个代理类,在代理类里面写“记录用户行为”的功能就好,不修改类,只拓展类,减少错误发生。

    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 静态代理类必须实现接口,而且需要新创建一个类的代码出来
     * @author Administrator
     *
     */
    public class StaticProxy implements IUser {
        private IUser user;
        public StaticProxy(String userId,String password){
            this.user = new User(userId,password);
        }
        
        //登陆前的操作,记录当前登录的时间
        void noteLoginInfo(String[] params, String opreate){
            Map<String,Object> loginInfo = new HashMap<>();
            loginInfo.put("params", params);
            loginInfo.put("opreate", opreate);
            loginInfo.put("opreateTime", new Date());
            System.out.println("记录用户操作成功");
        }
        
        @Override
        public void login(String userId, String password){
            
            noteLoginInfo(new String[]{userId, password},"login");
            
            user.login(userId, password);
        }
    
        @Override
        public void editNickname(String nickname) {
            noteLoginInfo(new String[]{nickname},"editNickname");
            user.editNickname(nickname);
        }
    
    }

    客户端类:

    public class Client {
        public static void main(String[] args) {
            //不调用代理模式时
            IUser user = new User("firs","123");
            user.login("firs", "123");
            user.editNickname("大风");
            
            System.out.println("");
            System.out.println("=============调用静态代理模式后===========");
            
            //需要实现记录用户登录和修改昵称操作的日志功能
            //基于“拓展开发,修改关闭”的设计准则,我们可以用静态代理的方式
            IUser proxy = new StaticProxy("firs","123");
            proxy.login("firs", "123");
            proxy.editNickname("我还是大风");    
    
    }

    这样子只需要修改客户端类和增加静态代理就可以了,完美实现。可是需求是无穷无尽的,产品经理跟你说:“我们增加了一个管理员角色,还有二级管理员”啥啥啥的一大堆角色,

    这就尴尬了,每个角色都要建一个静态代理类,类爆炸了吧。不急,我们有动态代理模式。

    动态代理模式在于不用自己新建代理类,你传具体的实现类(主体)给他,他就默认给你生成了一个代理类。

    从本质上来说,它是利用了java的反射机制在运行时动态地生成了相应的代理类。

    没有反射,就没有动态代理。

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 动态代理类不用和主体类继承同一个接口
     * @author Administrator
     *
     */
    public class DynamicProxy implements InvocationHandler {
        private Object object;
        public DynamicProxy(String userId,String password,Class<?> c){
            Object obj = null;
            try {
                obj = Class.forName(c.getName())
                        .getConstructor(String.class,String.class)
                        .newInstance(userId,password);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            this.object = obj;
        }
        
        //登陆前的操作,记录当前登录的时间
        void noteLoginInfo(String[] params, String opreate){
            Map<String,Object> loginInfo = new HashMap<>();
            loginInfo.put("params", params);
            loginInfo.put("opreate", opreate);
            loginInfo.put("opreateTime", new Date());
            System.out.println("记录用户操作成功");
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            String[] params = new String[args.length];
            for(int i = 0 ;i < args.length ; i++){
                params[i] = args[i].toString();
            }
            noteLoginInfo(params, method.getName());
            return method.invoke(object, args);
        }
    
    }

    最后的客户端类:

    package com.test.my;
    
    import java.lang.reflect.Proxy;
    
    
    public class Client {
        public static void main(String[] args) {
            //不调用代理模式时
            IUser user = new User("firs","123");
            user.login("firs", "123");
            user.editNickname("大风");
            
            System.out.println("");
            System.out.println("=============调用静态代理模式后===========");
            
            //需要实现记录用户登录和修改昵称操作的日志功能
            //基于“拓展开发,修改关闭”的设计准则,我们可以用静态代理的方式
            IUser proxy = new StaticProxy("firs","123");
            proxy.login("firs", "123");
            proxy.editNickname("我还是大风");
            
            System.out.println("");
            System.out.println("=============调用动态代理模式后===========");
            
            DynamicProxy dynamicProxy = new DynamicProxy("firs","123",Admin.class);
            
            ClassLoader cl = Admin.class.getClassLoader();
            IUser iuser = (IUser)Proxy.newProxyInstance(cl,
                                    new Class[]{IUser.class}, dynamicProxy);
            iuser.login("firs","123");
            iuser.editNickname("使用动态代理后的大风");
            
        }
    
    }

     因为需求而增加的Admin类

    public class Admin implements IUser {
        
        private String nickname;
        private String userId;
        private String password;
        
        public Admin(String userId,String password){
            this.userId = userId;
            this.password = password;
        }
    
        @Override
        public void login(String userId, String password){
            if(this.userId == userId && this.password == password){
                System.out.println("用户登录成功");
            }
            else
                System.out.println("用户登录失败");
        }
    
        @Override
        public void editNickname(String nickname) {
            this.nickname = nickname;
            System.out.println("修改昵称成功,当前用户的昵称是:"+this.nickname);
        }
    
    }

    总结:1.静态代理模式相对来说比较简单,要点在于对于每个实现类(subject主体)新建一个代理类,该代理类内有实体类(subject主体)的引用,从而可以实现对原有实现类(subject主体)的控制,包括aop的控制等。

               2.静态代理是有局限性的,对于每个实体类可能都需要新建一个静态代理类,这样子可能会造成静态代理类过多的情况,所以动态代理应运而生了。

               3.动态代理不局限于具体的实现类(subject主体),在其内部是用object存取实体类的引用,再利用反射获得该实体类的各种方法,从而实现对实现类(subject主体)的面向 切面AOP编程控制。

               4.上述的写法是JDK里的动态代理,不是特别完美,因为这种动态代理需要实体类实现至少一个接口。问题是并不是所有的类都会有接口,所以说不完美在这里。

               以上都是我自己对于代理模式的理解,如有错漏,还请批评指正,多谢。

  • 相关阅读:
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    xgqfrms™, xgqfrms® : xgqfrms's offical website of GitHub!
    直播丨国产最强音:HTAP融合型分布式数据库EsgynDB架构详解
    20个MySQL高性能架构设计原则(收藏版)
    RocketMQ进阶-延时消息
    Volatility2.6用法
    【LeetCode】112.路径总和(递归和迭代实现,Java)
  • 原文地址:https://www.cnblogs.com/sundaymorning/p/7579540.html
Copyright © 2020-2023  润新知