23种设计模式简单理解

工程模式

核心就是if，else if，else，在构造函数中传入不同参数就生成不同的产品

菜鸟教程-工厂模式

抽象工厂模式

工厂模式的工厂模式叫抽象工厂模式

spring中beanfactory应用了抽象工厂模式

单例模式

1. 构造函数是私有的
2. 提供一个访问它的全局访问点

建造者模式

菜鸟教程-建造者模式
类似于A套餐，B套餐的思想，客户直接点要A，还是要B，不必花时间再去自己挑选组装，考虑如何划算又营养。因为A套餐已经给你都考虑好了。使用的时候直接.builderA()就ok了

public class MealBuilder {
 
   public Meal prepareVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
 
   public Meal prepareNonVegMeal (){
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

原型模式

就是实现Cloneable，重写clone方法，然后利用了hashmap缓存对象，需要时再从map中取出来利用对象的clone方法拷贝一份给返回，而不是直接返回取出的对象。

public class Shape implements Cloneable {
  @Override
    protected Object clone()  {
        return super.clone();
    }
}    

Java中Cloneable的使用以及深浅克隆

• 浅克隆（shallow clone），浅克隆是指拷贝对象时仅仅copy对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象。

• 深克隆（deep clone），不仅copy对象本身，而且copy对象包含的引用指向的所有对象。

举例：对象X中包含对Y的引用，Y中包含对Z的引用。浅拷贝X得到X1，X1中依然包含对Y的引用，Y中依然包含对Z的引用。深拷贝则是对浅拷贝的递归，深拷贝X得到X1，X1中包含对Y1（Y的copy）的引用，Y1中包含对Z1（Z的copy）的引用。

适配器

菜鸟教程

• 场景：有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。
• 注意事项：适配器不是在详细设计时添加的，而是解决正在服役的项目的问题。
• 缺点：过多使用，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，

图书馆插座是3孔的，手机充电头需要2孔的，这时候就需要有个适配器（插板）一边是3孔，一边是2孔，来连接两端，实现充电。

过滤器(循环)

菜鸟教程-过滤器
对象数组按照不同标准过滤成几个子数组

比如转码规则就是用了过滤器模式。

责任链模式(循环)

public abstract class AbstractLogger {
   public static int INFO = 1;
   public static int DEBUG = 2;
   public static int ERROR = 3;
 
   protected int level;
 
   //责任链中的下一个元素
   protected AbstractLogger nextLogger;
 
   public void setNextLogger(AbstractLogger nextLogger){
      this.nextLogger = nextLogger;
   }
 
   public void logMessage(int level, String message){
      //这是递归调用的出口
      if(this.level <= level){
         write(message);
      }
      //这个地方执行了递归调用
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }
   abstract protected void write(String message);
}

过滤器(filter)与拦截器(intercepter)相同点:

1. 都可以拦截请求,过滤请求
2. 都是应用了过滤器(责任链)设计模式

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        HttpSession session=httpServletRequest.getSession();
        if(session.getAttribute("login")==null){
            httpServletResponse.sendRedirect("/login");
            return false;
        }else {
            System.out.println("ip:"+httpServletRequest.getRemoteHost()+"url"+httpServletRequest.getRequestURL()) ;
            return true;
        }
    }

    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

    }
}

public class MyFileter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
// 实际
        HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse;

        // 如果调用了这个方法,过滤器就会继承往下执行,
        HttpSession session = httpServletRequest.getSession();
        if (session.getAttribute("login") == null) {
            //没有登陆
            httpServletResponse.sendRedirect("/login");
            //return false;
        } else {
            System.out.println("ip:" + httpServletRequest.getRemoteHost() + ",url:" + httpServletRequest.getRequestURL());
            filterChain.doFilter(servletRequest, servletResponse);
            //return true;
        }

    }

    @Override
    public void destroy() {

    }
}

观察者模式(循环)

public class Subject {
   
   private List<Observer> observers 
      = new ArrayList<Observer>();
   private int state;
 
   public int getState() {
      return state;
   }
 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
 
   public void attach(Observer observer){
      observers.add(observer);      
   }
 
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}