代理模式【介绍、静态代理、动态代理、入门、应用】

迈不过友情╰ 2021-09-17 05:56 277阅读 0赞

# 代理介绍 #

> 代理（Proxy）是一种设计模式， 提供了对目标对象**另外的访问方式**；即**通过代理访问目标对象**。 这样好处： **可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。**

**可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。**

![这里写图片描述][SouthEast]

# 简单理解代理 #

很简单举个例子：

*  现在我是一个明星，拥有很多粉丝。粉丝希望我唱歌给他们听，但是如果都是我来接应他们，我岂不是很忙….于是乎，我就去找了个经纪人。这个**经纪人就代表了我**。当粉丝想要我唱歌的时候，应该是找经纪人，告诉经纪人想让我唱歌。
 *  现在我越来越红了，不是粉丝想要我唱歌，我就唱了。我要收费了。但是呢，作为一个公众人物，不可能是我自己说：我要收10000万，我才会去唱歌。于是这就**让经纪人对粉丝说：只有10000万，我才会唱歌。**
 *  无论外界是想要我干什么，都要经过我的经纪人。我的**经纪人也会在其中考虑收费、推脱它们的请求。**

**经纪人就是代理，实际上台唱歌、表演的还是我**

# 静态代理 #

直接使用例子来说明吧…现在我**有一个IUserDao的接口，拥有save方法()**

// 接口
    public interface IUserDao {
    
        void save();
    }

*  **UserDao实现该接口，重写save()方法**

public class UserDao implements IUserDao{ @Override public void save() { System.out.println("-----已经保存数据！！！------"); } }

现在，我想要在**save()方法保存数据前开启事务、保存数据之后关闭事务**…(当然啦，直接再上面写不就行了吗…**业务方法少的时候，确实没毛病**…)

public void save() {
    
            System.out.println("开启事务");
            System.out.println("-----已经保存数据！！！------");
    
            System.out.println("关闭事务");
        }

但是呢，现在如果我有好多好多个业务方法都需要开启事务、关闭事务呢？

public void save() { System.out.println("开启事务"); System.out.println("-----已经保存数据！！！------"); System.out.println("关闭事务"); } public void delete() { System.out.println("开启事务"); System.out.println("-----已经保存数据！！！------"); System.out.println("关闭事务"); } public void update() { System.out.println("开启事务"); System.out.println("-----已经保存数据！！！------"); System.out.println("关闭事务"); } public void login() { System.out.println("开启事务"); System.out.println("-----已经保存数据！！！------"); System.out.println("关闭事务"); }

…..我们发现就**有了很多很多的重复代码了**…我们要做的就是：当**用户调用UserDao方法的时候，找的是代理对象、而代理帮我在解决这么繁琐的代码**

于是呢，我们就**请了一个代理了**

*  **这个代理要和userDao有相同的方法…没有相同的方法的话，用户怎么调用啊？？**
 *  **代理只是对userDao进行增强，真正做事的还是userDao..**

因此，我们的代理就要实现IUserDao接口，这样的话，代理就跟userDao有相同的方法了。

public class UserDaoProxy implements IUserDao{ 
    
        // 接收保存目标对象【真正做事的还是UserDao】，因此需要维护userDao的引用
        private IUserDao target;
        public UserDaoProxy(IUserDao target) {
            this.target = target;
        }
    
        @Override
        public void save() {
            System.out.println("开始事务...");
    
            target.save();          // 执行目标对象的方法
    
            System.out.println("提交事务...");
        }
    }

**外界并不是直接去找UserDao,而是要通过代理才能找到userDao**

public static void main(String[] args) {
            // 目标对象
            IUserDao target = new UserDao();
    
            // 代理
            IUserDao proxy = new UserDaoProxy(target);
            proxy.save();  // 执行的是，代理的方法
        }

这样一来，我们在UserDao中就不用写那么傻逼的代码了…傻逼的事情都交给代理去干了…

# 为什么要用动态代理？ #

我们首先来看一下**静态代理的不足**：

*  **如果接口改了，代理的也要跟着改，很烦！**
 *  **因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。**

动态代理比静态代理好的地方：

*  代理对象，不需要实现接口【就不会有太多的代理类了】
 *  代理对象的生成，是利用JDKAPI， **动态地在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；**)

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

# 动态代理快速入门 #

**Java提供了一个Proxy类，调用它的newInstance方法可以生成某个对象的代理对象,该方法需要三个参数：**

![这里写图片描述][SouthEast 1]

*  参数一：生成代理对象使用哪个类装载器【一般我们使用的是代理类的装载器】
 *  参数二：生成哪个对象的代理对象，通过接口指定【指定要代理类的接口】
 *  参数三：生成的代理对象的方法里干什么事【实现handler接口，我们想怎么实现就怎么实现】

在编写动态代理之前，要明确两个概念：

*  **代理对象拥有目标对象相同的方法【因为参数二指定了对象的接口】**
 *  **用户调用代理对象的什么方法，都是在调用处理器的invoke方法。**
 *  **使用JDK动态代理必须要有接口【参数二需要接口】**

## 对象 ##

小明是一个明星，拥有唱歌和跳舞的方法。实现了人的接口

public class XiaoMing implements Person { 
    
        @Override
        public void sing(String name) {
    
            System.out.println("小明唱" + name);
        }
    
        @Override
        public void dance(String name) {
    
            System.out.println("小明跳" + name);
    
        }
    }

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

## 接口 ##

public interface Person {
        void sing(String name);
    
        void dance(String name);
    }

## 代理类 ##

public class XiaoMingProxy { 
    
        //代理只是一个中介，实际干活的还是小明，于是需要在代理类上维护小明这个变量
        XiaoMing xiaoMing = new XiaoMing();
    
    
        //返回代理对象
        public Person getProxy() {
    
            /** * 参数一：代理类的类加载器 * 参数二：被代理对象的接口 * 参数三：InvocationHandler实现类 */
            return (Person)Proxy.newProxyInstance(XiaoMingProxy.class.getClassLoader(), xiaoMing.getClass().getInterfaces(), new InvocationHandler() {
    
                /** * proxy : 把代理对象自己传递进来 * method：把代理对象当前调用的方法传递进来 * args:把方法参数传递进来 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                    //如果别人想要让小明唱歌
                    if (method.getName().equals("sing")) {
    
                        System.out.println("给1000万来再唱");
    
                        //实际上唱歌的还是小明
                        method.invoke(xiaoMing, args);
                    }
                    return null;
                }
            });
    
        }
    }

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

## 测试类 ##

public static void main(String[] args) {
    
            //外界通过代理才能让小明唱歌
            XiaoMingProxy xiaoMingProxy = new XiaoMingProxy();
            Person proxy = xiaoMingProxy.getProxy();
    
    
            proxy.sing("我爱你");
    
        }

![Qfh0Dfj.png][]

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

# 动态代理应用 #

我们之前写中文过滤器的时候，需要使用包装设计模式来设计一个request类。如果不是Servlet提供了实现类给我们，我们使用包装设计模式会出现麻烦

现在我们学习了动态代理了，动态代理就是**拦截直接访问对象，可以给对象进行增强的一项技能**

## 中文过滤器 ##

public void doFilter(final ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
            final HttpServletRequest request = (HttpServletRequest) req;
            HttpServletResponse response = (HttpServletResponse) resp;
    
            response.setContentType("text/html;charset=UTF-8");
            request.setCharacterEncoding("UTF-8");
    
    
            //放出去的是代理对象
            chain.doFilter((ServletRequest) Proxy.newProxyInstance(CharacterEncodingFilter.class.getClassLoader(), request.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                    //判断是不是getParameter方法
                    if (!method.getName().equals("getParameter")) {
    
                        //不是就使用request调用
                       return method.invoke(request, args);
                    }
    
                    //判断是否是get类型的
                    if (!request.getMethod().equalsIgnoreCase("get")) {
                       return method.invoke(request, args);
                    }
    
                    //执行到这里，只能是get类型的getParameter方法了。
                    String value = (String) method.invoke(request, args);
                    if (value == null) {
                        return null;
                    }
                    return new String(value.getBytes("ISO8859-1"), "UTF-8");
                }
    
            }), response);
    
        }

[SouthEast]: /images/20210827/8e3bbd0703924350bf696da8ce1fd47b.png
[SouthEast 1]: /images/20210827/c0d327ff456b4b3ba73c432e8b97d953.png
[Qfh0Dfj.png]: http://i.imgur.com/Qfh0Dfj.png