工厂模式

工厂方式模式

工厂模式核心

工厂注入模式

• 先定义一个工厂接口

   public interface TimeInterface {

    /**
     * 将字符串转为特定格式
     * @param s
     * @return
     */
    String timeToUpper(String s);
}

• 具体的实现类1

  /**
 * @author lwh
 * @description: 中文时间格式化工具类
 * @date: 2023/6/29 15:01
 */
public class TimeCnFormat implements TimeInterface{

    /***
     * @author lwh
     * function: 将数字转化为中文大写日期格式
     * @createDate 2023-6-29 下午15:33:12
     * @param time 日期
     * @return 转换后的中文大写日期格式
     */
    @Override
    public String timeToUpper(String time) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        String timeFormat = null;
        if (time != null && StringUtils.isNotBlank(time)) {
            Date format = null;
            try {
                format = df.parse(time);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            //时间转大写
            timeFormat = DateUtil.dataToUpper(format);
        }
        return timeFormat;
    }  

• 具体的实现类2

      public class TimeNumFormat implements TimeInterface{


    /***
     * @author lwh
     * function: 将数字转化为yyyy年MM月dd日格式
     * @createDate 2023-6-29 下午15:18:12
     * @param time 日期
     * @return 转换后的yyyy年MM月dd日格式
     */
    @Override
    public String timeToUpper(String time) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat dTime = new SimpleDateFormat("yyyy年MM月dd日");
        String format = null;
        if (time != null && StringUtils.isNotBlank(time)) {
            Date parse = null;
            try {
                parse = df.parse(time);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            format = dTime.format(parse);
        }
        return format;
    }

• 创建一个工厂注册，返回

    /**
 * @author lwh
 * date 2023-6-30
 */
@Component
public class TimeFormatFactory {

    /**
     * 分组注册表信息:key-分组名称，value-分组注册表
     */
    private final Map<String, TimeInterface> map = new HashMap<>();

    public TimeFormatFactory() {
        this.registerTimeFormat();
    }

    /**
     * 注册
     * @param
     */
    public void register(String type,TimeInterface timeInterface) {
        map.put(type,timeInterface);
    }

    /**
     * 注册时间类
     */
    private void registerTimeFormat() {
        TimeCnFormat timeCnFormat = new TimeCnFormat();
        this.register(DateCnEnum.DATECN.name(),timeCnFormat);
        TimeNumFormat timeNumFormat = new TimeNumFormat();
        this.register(DateNumEnum.DATETYPE2.name(),timeNumFormat);
    }

    /**
     * 获取时间类
     * @param stringTime
     * @return
     */
    public TimeInterface getTimeFormat(String stringTime) {
        if(stringTime.indexOf(DateNumEnum.DATETYPE2.name()) != -1){
            return map.get(DateNumEnum.DATETYPE2.name());
        }else if (stringTime.indexOf(DateCnEnum.DATECN.name()) != -1){
            return map.get(DateCnEnum.DATECN.name());
        }
       return null;
    }

• 调用

      public void customTimeFormat(Map<String, Object> data, Map<String, String> entry, String text) {
        //截取每个值,分割{{}}
        String[] split = text.split("[{{}}]");
        for (String s : split) {
            //从注册中拿到对应的类型，返回对应格式的方法
            TimeInterface cn = timeFormatFactory.getTimeFormat(s);
            if (cn!=null) {
                //截取l前的日期key值
                String vKey = s.substring(0, s.indexOf("l"));
                String value = entry.get(vKey);
                //转换格式
                String time = cn.timeToUpper(value);
                data.put(s, StringUtils.isEmpty(time) ? "" : time);
            }
        }
    }
        

简单工厂模式

创建一个汽车接口

package com.liang.factory.simple;

public interface Car {
    void name();
}

package com.liang.factory.simple;


//静态工厂模式
//增加一个新的产品，如果你不修改代码，做不到！

//开闭原则
public class CarFactory {

   //方法一：
    public static Car getCar(String car) {
        if (car.equals("五菱!")) {
            return new WuLing();
        } else if (car.equals("特斯拉!")) {
            return new Tesla();
        } else if (car.equals("大众")) {
                return new Dazhong();
        } else {
            return null;
        }

        }
        


    }

创建三个汽车品牌类

package com.liang.factory.simple;

public class Dazhong  implements Car{

    @Override
    public void name() {
        System.out.println("我是大众啊！");
    }
}
---------------------------------------------------------------

package com.liang.factory.simple;

public class Tesla implements Car{
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}
---------------------------------------------------------------
package com.liang.factory.simple;

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}

创建一个消费者

package com.liang.factory.simple;

public class Consumer {
    public static void main(String[] args) {
      //接口，所有的实现类！工厂
       // Car car=new WuLing();
        //Car car1=new Tesla();

        //2.使用工厂创建
        Car car = CarFactory.getCar("五菱!");
        Car car1= CarFactory.getCar("特斯拉!");
        Car car2 = CarFactory.getCar("大众");

        car.name();
        car1.name();
        car2.name();
    }
}

工厂方式模式

创建一个汽车接口和汽车工厂接口也作为约束

package com.liang.factory.method;

public interface Car {
    void name();
}
---------------------------------------------------------------
package com.liang.factory.method;

//工厂方法模式
public interface CarFactory {
    Car getCar();
}

创建汽车品牌类和各自的工厂类

package com.liang.factory.method;

public class MoBai  implements Car{
    @Override
    public void name() {
        System.out.println("hello，我是摩拜单车");
    }
}
--------------------------------------------------------------
 package com.liang.factory.method;

public class MoBaiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new MoBai();
    }
}

package com.liang.factory.method;

public class WuLing implements Car {
    @Override
    public void name() {
        System.out.println("五菱宏光");
    }
}
--------------------------------------------------------------
  package com.liang.factory.method;

public class WuLingFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new WuLing();
    }
}

package com.liang.factory.method;

public class Tesla implements Car {
    @Override
    public void name() {
        System.out.println("特斯拉");
    }
}
--------------------------------------------------------------
 package com.liang.factory.method;

public class TeslaFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Tesla();
    }
}
 

创建一个消费者类，遵守了开闭原则，每次添加新汽车都不动她原来的类

package com.liang.factory.method;

import com.liang.factory.simple.CarFactory;

public class Consumer {
    public static void main(String[] args) {
        Car car = new WuLingFactory().getCar();
        Car car1 = new TeslaFactory().getCar();
        Car car2 = new MoBaiFactory().getCar();

        car.name();
        car1.name();
        car2.name();
    }
}

小结：

• 结构复杂度 simple
• 代码复杂度 simple
• 编程复杂度 simple
• 管理上的复杂度 simple

根据设计原则：工厂方法模式！

根据实际业务：简单工厂模式！