JAVA设计模式(篇四)

五-建造者模式

在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。如电脑由CPU，主板，内存 ，显卡，散热等等部件组成，用户购买电脑时不想自己组装，则直接向商家提出购买需求，然后由商家安排技术人员进行电脑组装，组装完成后再拿给用户。

类似的产品由多个部件构成，每个部件可以有不同的选择，此时用建造者模式能更清晰的描述产品该类型的创建。

1.模式的定义与特点

1. 建造者模式定义：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

2. 优点：

• 各个具体的建造者相互独立，有利于系统的扩展。
• 客户端不必知道产品内部组成的细节，便于控制细节风险。

3. 缺点：

• 产品的组成部分必须相同，这限制了其使用范围。
• 如果产品的内部变化复杂，该模式会增加很多的建造者类。

建造者模式和工厂模式的关注点不同: 建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

2. 模式的结构和实现

建造者模式由产品，抽象建造者 ，具体建造者，指挥者四部分组成

1. 模式的结构

• 产品：包含多个组成部件的复杂对象，由具体建造者创建各个部件
• 抽象建造者：包含创建产品各个部件的方法的抽象接口，一般还包含返回复杂产品的方法(getResult)
• 具体建造者：继承抽象建造者，实现复杂产品的各个部件的创建。
• 指挥者： 调用建造者对象中的部件构造与装配方法完成复杂对象的创
  建，在指挥者中不涉及具体产品的信息。

2.模式的实现

//具体产品
@Data
public class ProductPojo {
    //部件A B C
    private String partA;
    private String partB;
    private String partC;
    //展示该产品
    public void showPart(){
        System.out.println(this.partA);
        System.out.println(this.partB);
        System.out.println(this.partC);
    }
}
//抽象构造者
public abstract class ProductBuilder {
    //创建产品对象
    protected ProductPojo productPojo = new ProductPojo();
    //构建产品部件A B C 的抽象方法
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();

    //返回产品对象
    public ProductPojo getResult(){
        return productPojo;
    }

}
//具体产品构建者 这个类中包含了产品的构造细节
public class ConCreateBuilder extends ProductBuilder{

    @Override
    public void buildPartA() {
        productPojo.setPartA("构建了产品部件A");
    }

    @Override
    public void buildPartB() {
        productPojo.setPartB("构建了产品部件B");
    }

    @Override
    public void buildPartC() {
        productPojo.setPartC("构建了产品部件C");
    }
}

//指挥者 通过具体建造者去构建各个部件，最终返回产品
public class Director {

    private ProductBuilder builder;

    public Director(ProductBuilder builder){
        this.builder = builder;
    }

    //产品构建与组装方法
    public ProductPojo createProduct(){
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }

}
//客户端测试
@Test
void testBuilder(){
    ProductBuilder productBuilder = new ConCreateBuilder();//生成具体建造者
    Director director =  new Director(productBuilder);//生成指挥者对象
    ProductPojo product = director.createProduct();//通过指挥者创建对应的产品
    product.showPart();//展示产品的细节
}
//输出 构建了产品部件A    构建了产品部件B    构建了产品部件C

3.模式的应用场景

建造者（Builder)模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

• 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的
• 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

4.模式的扩展

建造者(Builder)模式在应用过程中可以根据需求改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。

六-代理模式

在某些情况下，客户不能或者不想直接访问一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。如网上购买火车票， 找中介租房等。

1.模式的定义与特点

代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

优点：

• 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用;
• 代理对象可以扩展目标对象的功能;
• 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度;

缺点：

• 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢;
• 增加了系统的复杂度;

2.模式的结构和实现

tips：主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问

1.代理模式的结构

• 抽象主题 ：通过接口或抽象类声明真实主题和代理对象实现业务的方法
• 真实主题：实现抽象主题的具体业务，是代理对象代表的真实对象，是最终需要引用的对象。
• 代理：提供了与真实主题相同的接口，其内部包含对真实主题的引用，具有访问，控制，扩展真实主题的功能。

2.代理模式的实现

//抽象主题=房子
public interface House {

    void leaseHouse();
}
//真实主题=公寓
public class ApartmentHouse implements House{

    @Override
    public void leaseHouse() {
        System.out.println("租到公寓了");
    }
}
//代理=房屋中介
public class HouseProxy {

    private ApartmentHouse apartmentHouse;
    //和真实主题相同的方法
    public void leaseHouse() {
        if (null==apartmentHouse){
            apartmentHouse = new ApartmentHouse();
        }
        //引用前的处理
        preRentHouse();
        //实际是对真实主题的引用
        apartmentHouse.leaseHouse();
        //引用后的处理
        postRentHouse();
    }

    public void preRentHouse(){
        System.out.println("租房前，房屋中介带着看房子");
    }
    public void postRentHouse(){
        System.out.println("确认租房后，跟房屋中介签合同");
    }

}
//模拟客户端测试
@Test
void testProxy(){
    HouseProxy houseProxy = new HouseProxy();
    houseProxy.leaseHouse();
}    
//输出  租房前，房屋中介带着看房子        租到公寓了     确认租房后，跟房屋中介签合同

3. 代理模式的应用场景

• 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘,用户访问虚拟硬盘时实际访问的是网盘空间。
• 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
• 安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。
• 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。
• 延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate中就存在属性的延迟加载和关联表的延时加载。

4.代理模式的扩展

代理类中包含了对真实主题的引用, 这种方式存在两个缺点：

• 真实主题与代理主题―—对应，增加真实主题也要增加代理。

• 设计代理以前真实主题必须事先存在（静态代理），不太灵活。采用动态代理模式可以解决以上问题，如Spring AOP（结构如下图）

  

动态代理的实现：

//抽象主题类=房子
public interface House {
    //租房方法
    void leaseHouse();
}
//真实主题=公寓
public class ApartmentHouse implements House{

    @Override
    public void leaseHouse() {
        System.out.println("租到公寓了");
    }
}
//动态代理
public class HouseDynamicProxy<T> implements InvocationHandler {

    private T proxyClass;

    public HouseDynamicProxy(T proxyClass){
        this.proxyClass = proxyClass;
    }
    /**
     * proxy 动态代理对象
     * method 正在执行的方法
     * args 调用目标方法时的入参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        preRentHouse();
        Object invoke = method.invoke(proxyClass, args);
        postRentHouse();
        return invoke;
    }

    public void preRentHouse(){
        System.out.println("租房前，房屋中介带着看房子");
    }
    public void postRentHouse(){
        System.out.println("确认租房后，跟房屋中介签合同");
    }
}
//模拟测试
@Test
void testDynamicProxy(){
    //创建一个真实主题
    ApartmentHouse apartmentHouse = new ApartmentHouse();
    //创建动态代理
    InvocationHandler invocationHandler = new HouseDynamicProxy(apartmentHouse);
    //通过代理生成一个抽象主题
    House house = (House)Proxy.newProxyInstance(House.class.getClassLoader(),new Class<?>[]{House.class}, invocationHandler);
    //执行目标方法
    house.leaseHouse();
}

//输出   租房前，房屋中介带着看房子      租到公寓了       确认租房后，跟房屋中介签合同

tips： spring aop动态代理是jdk动态代理，需要被代理的类实现对应的接口（如公寓ApartmentHouse必须 实现房子House的接口），如果需要被代理的类没有实现接口，则需要使用CGLib代理实现

CGlib动态代理 ：

Cglib动态代理也叫作子类代理，他是通过在内存中构建一个子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，然后加入自己需要的操作。因为使用的是继承的方式，所以不能代理final 类。