23种设计模式之代理模式

代理模式：

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

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

　  联想公司它本身能够生产电脑，也能够本身销售电脑，这就比如咱们建立的真是对象有两个方法同样，经销商能够卖电脑，可是他不能生产电脑，电脑从哪里来？确定是从联系公司进货，而后在销售，这就至关于代理对象调用了真实对象生产电脑的方法。

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

 

 代理模式的一些基本概念　　　　

　　真实对象：被代理的对象

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

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

代理模式实现方式有两种

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

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

 

实现步骤：

1. 代理对象和真实对象实现相同的接口
2. 建立代理对象 = Proxy.newProxyInstance();
3. 使用代理对象调用方法。
4. 加强方法

加强方式：

1. 加强参数列表
2. 加强返回值类型
3. 加强方法体执行逻辑

 

简单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() {
    }

}