23种设计模式之代理模式

代理模式：

老师上课讲的比较通俗易懂，总结记录一下。

　　如下图，比如我需要去买一台联想电脑，但是联想总部在北京，我人在西安，如果联想公司在西安没有代理经销商，那我需要去北京总部购买，耗时耗力。但是如果联想在你当地有设经销商，那么我们需要购买笔记本这个需求，就变得非常简单了，只需要去当地门店即可，应该很好理解了。

　联想公司它自己可以生产电脑，也可以自己销售电脑，这就好比我们创建的真是对象有两个方法一样，经销商可以卖电脑，但是他不能生产电脑，电脑从哪里来？肯定是从联系公司进货，然后在销售，这就相当于代理对象调用了真实对象生产电脑的方法。

　　同时代理对象可以为用户提供真是对象完成它不能不了的动能，可能说到这里，对于代理模式的一些基本认识就应该大致了解了，所以使用代理模式，简而言之可以增强对象的功能，而Java中所谓的23中设计模式，也就是一些通用的解决固定问题的方式。

代理模式的一些基本概念　　　　

　　真实对象：被代理的对象

　　代理对象：代替真实对象的对象

　　代理模式：代理对象代理真实对象，达到增强真实对象功能的目的。（理论性的东西，知道是什么意思就好，不必纠结）

代理模式实现方式有两种

　　1. 静态代理：有一个类文件描述代理模式

　　2. 动态代理：在内存中形成代理类（动态代理相对灵活一些，使用动态代理比使用静态代理对一些）

实现步骤：

代理对象和真实对象实现相同的接口
创建代理对象 = Proxy.newProxyInstance();
使用代理对象调用方法。
增强方法

增强方式：

增强参数列表
增强返回值类型
增强方法体执行逻辑

简单Demo

定义接口和方法

public interface SaleComputer {

    public String sale(double money);

    public void show();

}

这是你的真实对象

//真实的类   联想公司
public class Lenovo implements SaleComputer {

    @Override
    public String sale(double money) {
        System.out.println("花了" + money + "买了一台电脑");
        return "联想电脑";
    }

    @Override
    public void show() {
        System.out.println("展示电脑 ...");
    }
}

这是你的代理对象

public class ProxyTest {
    public static void main(String[] args) {
        //1.创建真实对象
        Lenovo lenovo = new Lenovo();

        //2.传递三个参数,
        // 参数一: 类加载器 真实对象.getClass().getClassLoader()
        // 参数二: 接口数组 真实对象.lenovo.getClass().getInterfaces()
        // 参数三: 处理器 new InvocationHandler()

        SaleComputer proxy_lenovo = (SaleComputer) Proxy.newProxyInstance(lenovo.getClass().getClassLoader(), lenovo.getClass().getInterfaces(), new InvocationHandler() {

            /**
             * 代理逻辑编写的方法:代理对象调用的所有方法都会被执行
             * @param proxy  代理对象
             * @param method 代理对象调用方法,被封装为的对象
             * @param args   代理对象调用方式时,传递的实际参数
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

               /*
                    System.out.println("该方法被执行了");
                    System.out.println(method.getName());
                    System.out.println(args[0]);
                */

                //增强参数  假设代理对象在真实对象拿货只要市场价的85%,经销商也要赚钱.那就需要修改原sale方法里的参数了.
                if (method.getName().equals("sale")) {
                    double money = (double) args[0]; //args[0]=8000
                    money = money * 0.85;  //增强后参数money变为6800

                    /*
                        使用真实对象调用该方法, Object obj = method.invoke(lenovo, args);
                        使用代理对象调用该方法, Object obj = method.invoke(lenovo, money);
                    */

                    String obj = (String) method.invoke(lenovo, money); 

                    //还可以增强方法体的逻辑：免费送货
                    System.out.println("免费送货上门");

                    //增强返回值,原方法只是返回一个电脑,现在还给你送点东西,自己理解哈，哈哈。
                    return obj+"_送你个鼠标垫";


                } else {
                    Object obj = method.invoke(lenovo, args);
                    return obj;
                }

            }
        });


        String computer = proxy_lenovo.sale(8000);
        System.out.println(computer);

        /*  proxy_lenovo.show();  没有被增强，执行的话会原样调用*/
    }
}

敏感词汇过滤需求实现就用到了动态代理来增强方法

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

@WebFilter("/*")
public class SensitiveWordsFilter implements Filter {

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        //1.创建代理对象，增强getParameter方法
        ServletRequest proxy_req = (ServletRequest) Proxy.newProxyInstance(req.getClass().getClassLoader(), req.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //增强getParameter方法
                //判断是否是getParameter方法
                if (method.getName().equals("getParameter")) {
                    //增强返回值
                    //获取返回值
                    String value = (String) method.invoke(req, args);
                    if (value != null) {
                        for (String str : list) {
                            if (value.contains(str)) {
                                value = value.replaceAll(str, "***");
                            }
                        }
                    }
                    return value;
                }

                //判断方法名是否是 getParameterMap

                //判断方法名是否是 getParameterValue

                return method.invoke(req, args);
            }
        });

        //2.放行
        chain.doFilter(proxy_req, resp);
    }

    private List<String> list = new ArrayList<String>();//敏感词汇集合

    public void init(FilterConfig config) throws ServletException {

        try {
            //1.获取文件真实路径
            ServletContext servletContext = config.getServletContext();
            String realPath = servletContext.getRealPath("/WEB-INF/classes/敏感词汇.txt");
            //2.读取文件
            BufferedReader br = new BufferedReader(new FileReader(realPath));
            //3.将文件的每一行数据添加到list中
            String line = null;
            while ((line = br.readLine()) != null) {
                list.add(line);
            }

            br.close();

            System.out.println(list);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public void destroy() {
    }

}

posted @ 2019-08-04 15:21 Courage.Kiven 阅读(253) 评论(0) 编辑收藏举报

刷新页面返回顶部

Courage.Kiven

此博客仅为记录总结所学知识。

23种设计模式之代理模式

代理模式：

公告