设计模式实践-小Demo示例

文章内容输出来源：拉勾教育Java高薪训练营

Builder建造者模式

如果一个对象的构建比较复杂，将其进行拆分成多个组件，再一步一步构建为一个复杂对象

示例Demo

汽车的构造很复杂，需要由很多的部件组合而成，像车轮、发动机、底盘这些。那么就可以拆分下，先去生产汽车的各个部件。再统一由一个汽车构建器，将各个生产完的部件组合在一起，创建一辆汽车。

1. 创建汽车类Car，汽车拥有发动机、底盘等部件属性

public class Car {
    //发动机
    private String engine;
     //底盘
    private String chassis;
    //车身
    private String body;
    //轮子
    private String wheel;
    //ignore getter/setter
}    

2. 创建汽车构建器CarBuilder，由它负责去组装各个部件，组装完成后通过build返回组装后的实例对象。并实现了组装过程的链式调用

public class CarBuilder {
    //构建的对象
    private Car target;

    public CarBuilder() {
        this.target = new Car();
    }

    /**
     * 组装车身
     * @param body
     * @return
     */
    public CarBuilder installBody(String body) {
        target.setBody(body);
        return this;
    }

    /**
     * 组装发动机
     * @param engine
     * @return
     */
    public CarBuilder installEngine(String engine) {
        target.setEngine(engine);
        return this;
    }

    /**
     * 组装轮子
    */

    public CarBuilder installWheel(String wheel) {
        target.setWheel(wheel);
        return this;
    }

    /**
     * 组装底盘
    */

    public CarBuilder installChassis(String chassis) {
        target.setChassis(chassis);
        return this;
    }

    /**
     * 最终构建一辆汽车
     * @return
     */
    public Car build() {
        return target;
    }

}

3. 客户端调用创建汽车CarMain

 public static void main(String[] args) {
        Car car = new CarBuilder()
                .installEngine("四缸发动机")
                .installBody("法拉利车身")
                .installWheel("米其林轮胎")
                .installChassis("法拉利底盘").build();
        //output:Car{engine='四缸发动机', chassis='法拉利底盘', body='法拉利车身', wheel='米其林轮胎'}
        System.out.println(car.toString());
    }

简单工厂模式

在简单工厂模式中，可以根据参数的不同返回不同类的实例。
简单工厂模式有一个专门的类，来负责创建目标类对象，被创建的对象具有共同父类。

示例Demo

有一个手机工厂，可以生产华为手机、小米手机

1. 创建手机基类Phone。手机有拨打的功能，加了一个call方法call

public abstract class Phone {
    /**
     * 拨打电话
     */
    public abstract void call(String phoneNumber);
}

2. 创建华为手机，继承手机基类HuaWeiPhone

public class HuaWeiPhone extends Phone {
    /**
     * 拨打电话
     *
     * @param phoneNumber
     */
    @Override
    public void call(String phoneNumber) {
        System.out.println("华为手机正在拨打电话：" + phoneNumber);
    }
}

3. 创建小米手机，继承手机基类XiaoMiPhone

public class XiaoMiPhone extends Phone {
    /**
     * 拨打电话
     *
     * @param phoneNumber
     */
    @Override
    public void call(String phoneNumber) {
        System.out.println("小米手机正在拨打电话：" + phoneNumber);
    }
}

4. 创建手机工厂PhoneFactory

public class PhoneFactory {
    /**
     * 生产手机
     * @param band
     * @return
     */
    public static Phone createPhone(String band) {
        Phone phone = null;

        switch (band) {
            case "小米":
                phone = new XiaoMiPhone();
                break;
            case "华为":
                phone = new HuaWeiPhone();
                break;
            default:
                break;
        }

        return phone;
    }
}

5. 客户端调用手机工厂去生产手机PhoneMain，生产完手机，测试下拨打电话功能

public class PhoneMain {
    public static void main(String[] args) {
        Phone xiaoMi = PhoneFactory.createPhone("小米");
        xiaoMi.call("110");

        Phone huaWei = PhoneFactory.createPhone("华为");
        huaWei.call("119");
        //output
        //小米手机正在拨打电话：110
        //华为手机正在拨打电话：119
    }
}

代理模式

代理模式，给某一个对象提供代理，并由代理对象控制对原对象的引用。代理可以扩展原对象，增强原对象的功能

示例Demo

因为使用了JDK动态代理，JDK动态代理需要目标类实现相应的接口

• 创建人的接口Person，有一个走路的接口方法walk

public interface Person {

    /**
     * 走路
     */
    void walk(String name);
}

• 实现人的接口PersonImpl

public class PersonImpl implements Person{
    /**
     * 走路
     */
    @Override
    public void walk(String name) {
        System.out.println("我在走路，我的名字叫" + name);
    }
}

• 创建代理人的类PersonProxy，实现InvocationHandler接口，在方法回调中对走路方法进行增强

public class PersonProxy implements InvocationHandler {
    //目标对象
    private Person target;
    public PersonProxy(Person person) {
        this.target = person;
    }

    //获取目标对象的代理对象
    public Person getTarget() {
        return (Person) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("请问有没有人在走路？(代理增强：目标方法执行前...)");
        Person result = (Person)method.invoke(target, args);
        System.out.println("好的，慢慢走，不要掉水沟！(代理增强：目标方法执行后...)");
        return result;
    }
}

• 客户端生成一个代理人ProxyMain

public class ProxyMain {
    public static void main(String[] args) {
        //获取人的代理对象
        Person proxy = new PersonProxy(new PersonImpl()).getTarget();
        //通过代理对象去调用人的走路方法，对走路方法进行了增强
        proxy.walk("张三");
        /**
         * output
         * 请问有没有人在走路？(代理增强：目标方法执行前...)
         * 我在走路，我的名字叫张三
         * 好的，慢慢走，不要掉水沟！(代理增强：目标方法执行后...)
         */
    }
}

项目代码

• 构建者模式示例
• 简单工厂模式示例
• 代理模式示例