Java设计模式：桥接模式解决的架构设计痛点

Myth丶恋晨 2024-02-19 20:02 5阅读 0赞

现象痛点：

现在创建一个工厂，工厂的日常运行是生产和销售。如：

public abstract class Factory {
        /**
         * 生产
         */
        public abstract void produce();
    
        /**
         * 销售
         */
        public abstract void sell();
    
        /**
         * 工厂运营。
         */
        public void operation() {
            produce();
            sell();
        }
    }

一个造船厂：

public class BoatFactory extends Factory{
        @Override
        public void produce() {
            System.out.println("制造船");
        }
    
        @Override
        public void sell() {
            System.out.println("销售船");
        }
    }

一个汽车厂：

public class CarFactory extends Factory{
        @Override
        public void produce() {
            System.out.println("生产汽车");
        }
    
        @Override
        public void sell() {
            System.out.println("销售汽车");
        }
    }

测试：

Factory factory = new CarFactory();
            factory.operation();

输出的是汽车厂的生产和销售活动。

但是现在问题来了，以这样的架构设计，如果有一天行业和市场发生变化，要开设一家制造手机的手机工厂，那以前创建和运转良好的船厂、汽车厂已有的资源均不能使用。工厂要转型生产手机，则需要重新布置手机生产的产线。换言之，以前那套架构转型成本太高，缺乏资源的复用，这是痛点。有没有一种连接（桥接、桥梁）办法，实现高内聚，低耦合工厂和产品？

--------------------

现在开始改进。

先把工厂生产和销售的对象抽象成Product模型：

public abstract class Product {
        /**
         * 产品生产
         */
        public abstract void produce();
    
        /**
         * 产品销售
         */
        public abstract void sell();
    }

抽象工厂，传入一个什么样的产品就生产和销售该产品：

public abstract class Factory {
        private Product product;
    
        public Factory(Product product) {
            this.product = product;
        }
    
        public void setProduct(Product product) {
            this.product = product;
        }
    
        /**
         * 工厂运营。
         */
        public void operation() {
            product.produce();
            product.sell();
        }
    }

具体的工厂实现：

public class SomeFactory extends Factory{
        public SomeFactory(Product product) {
            super(product);
        }
    }

那么原先的船和汽车作为产品的角色，分别抽象定义：

public class Boat extends Product {
        @Override
        public void produce() {
            System.out.println("生产船");
        }
    
        @Override
        public void sell() {
            System.out.println("销售船");
        }
    }

public class Car extends Product{
        @Override
        public void produce() {
            System.out.println("生产汽车");
        }
    
        @Override
        public void sell() {
            System.out.println("销售汽车");
        }
    }

测试：

Car car=new Car();
            Factory factory=new SomeFactory(car);
            factory.operation();
    
            Boat boat=new Boat();
            factory.setProduct(boat);
            factory.operation();

输出：

生产汽车
    销售汽车
    生产船
    销售船

如果市场行情发生变化，现在需要转型生产手机，那么只需要增加一款产品Phone即可，原有的工厂产线都得到复用：

public class Phone extends Product{
        @Override
        public void produce() {
            System.out.println("生产手机");
        }
    
        @Override
        public void sell() {
            System.out.println("销售手机");
        }
    }

测试：

Car car=new Car();
            Factory factory=new SomeFactory(car);
            factory.operation();
    
            Boat boat=new Boat();
            factory.setProduct(boat);
            factory.operation();
    
            Phone phone=new Phone();
            factory.setProduct(phone);
            factory.operation();

输出：

生产汽车
    销售汽车
    生产船
    销售船
    生产手机
    销售手机

附：

Java设计模式：桥接模式

https://blog.csdn.net/zhangphil/article/details/88721704

Java设计模式：装饰模式  
https://blog.csdn.net/zhangphil/article/details/88717828

Java设计模式：工厂模式  
https://blog.csdn.net/zhangphil/article/details/88713685

Java设计模式：工厂方法模式  
https://blog.csdn.net/zhangphil/article/details/88824777