其他分享
首页 > 其他分享> > 东软实训之享元模式

东软实训之享元模式

作者:互联网

简介

Use sharing to support large numbers of fine-grained objects efficiently.
使用共享对象可有效地支持大量的细粒度的对象。

享元模式(Flyweight)又称为 轻量级模式,它是一种对象结构型模式。

面向对象技术可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时,将导致运行代价过高,带来性能下降等问题。享元模式 正是为解决这一类问题而诞生的。

享元模式 是对象池的一种实现。类似于线程池,线程池可以避免不停的创建和销毁多个对象,消耗性能。享元模式 也是为了减少内存的使用,避免出现大量重复的创建销毁对象的场景。

享元模式 的宗旨是共享细粒度对象,将多个对同一对象的访问集中起来,不必为每个访问者创建一个单独的对象,以此来降低内存的消耗。

享元模式 把一个对象的状态分成内部状态和外部状态,内部状态即是不变的,外部状态是变化的;然后通过共享不变的部分,达到减少对象数量并节约内存的目的。

享元模式 本质:缓存共享对象,降低内存消耗

主要解决

当系统中多处需要同一组信息时,可以把这些信息封装到一个对象中,然后对该对象进行缓存,这样,一个对象就可以提供给多处需要使用的地方,避免大量同一对象的多次创建,消耗大量内存空间。

享元模式 其实就是 工厂模式 的一个改进机制,享元模式 同样要求创建一个或一组对象,并且就是通过工厂方法生成对象的,只不过 享元模式 中为工厂方法增加了缓存这一功能。

优缺点

优点

缺点

使用场景

模式讲解

首先来看下 享元模式 的通用 UML 类图:

img

享元模式

从 UML 类图中,我们可以看到,享元模式 主要包含三种角色:

以下是 享元模式 的通用代码:

class Client {
    public static void main(String[] args) {
        IFlyweight flyweight1 = FlyweightFactory.getFlyweight("aa");
        IFlyweight flyweight2 = FlyweightFactory.getFlyweight("bb");
        flyweight1.operation("a");
        flyweight2.operation("b");
    }

    // 抽象享元角色
    interface IFlyweight {
        void operation(String extrinsicState);
    }

    // 具体享元角色
    static class ConcreteFlyweight implements IFlyweight {
        private String intrinsicState;

        public ConcreteFlyweight(String intrinsicState) {
            this.intrinsicState = intrinsicState;
        }

        @Override
        public void operation(String extrinsicState) {
            System.out.println("Object address: " + System.identityHashCode(this));
            System.out.println("IntrinsicState: " + this.intrinsicState);
            System.out.println("ExtrinsicState: " + extrinsicState);
        }
    }

    // 享元工厂
    static class FlyweightFactory {
        private static Map<String, IFlyweight> pool = new HashMap<>();

        // 因为内部状态具备不变性,因此作为缓存的键
        public static IFlyweight getFlyweight(String intrinsicState) {
            if (!pool.containsKey(intrinsicState)) {
                IFlyweight flyweight = new ConcreteFlyweight(intrinsicState);
                pool.put(intrinsicState, flyweight);
            }
            return pool.get(intrinsicState);
        }
    }
}

举个例子

例子:我们知道,过年回家的时候很麻烦,因为我们需要抢到一张回家的火车票。抢票的时候,我们肯定是要查询下有没有我们需要的票信息,这里我们假设一张火车的信息包含:出发站,目的站,价格,座位类别。现在要求编写一个查询火车票查询伪代码,可以通过出发站,目的站查到相关票的信息。

直接思路:例子要求通过出发站,目的站查询火车票的相关信息,那么我们只需构建出火车票类对象,然后提供一个查询出发站,目的站的接口给到客户进行查询即可;
具体代码如下:

class Client {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.queryTicket("深圳北", "潮汕");
        ticket.showInfo("硬座");
    }

    interface ITicket {
        void showInfo(String bunk);
    }

    static class TrainTicket implements ITicket {
        private String from;
        private String to;
        private int price;

        public TrainTicket(String from, String to) {
            this.from = from;
            this.to = to;
        }

        @Override
        public void showInfo(String bunk) {
            this.price = new Random().nextInt(500);
            System.out.println(String.format("%s->%s:%s价格:%s 元", this.from, this.to, bunk, this.price));
        }
    }

    static class TicketFactory {
        public static ITicket queryTicket(String from, String to) {
            return new TrainTicket(from, to);
        }
    }
}

分析:上面的代码中,客户端进行查询时,系统通过TicketFactory直接创建一个火车票对象,但是这样做的话,当某个瞬间如果有大量的用户请求同一张票的信息时,系统就会创建出大量该火车票对象,系统内存压力骤增。而其实更好的做法应该是缓存该票对象,然后复用提供给其他查询请求,这样一个对象就足以支撑数以千计的查询请求,对内存完全无压力,使用 享元模式 可以很好地解决这个问题;
具体代码如下:只需对上面代码的TicketFactory进行更改,增加缓存机制:

class Client {
    public static void main(String[] args) {
        ITicket ticket = TicketFactory.queryTicket("深圳北", "潮汕");
        ticket.showInfo("硬座");
        ticket = TicketFactory.queryTicket("深圳北", "潮汕");
        ticket.showInfo("软座");
        ticket = TicketFactory.queryTicket("深圳北", "潮汕");
        ticket.showInfo("硬卧");
    }
    ...
    ...
    static class TicketFactory {
        private static Map<String, ITicket> sTicketPool = new ConcurrentHashMap<>();

        public static ITicket queryTicket(String from, String to) {
            String key = from + "->" + to;
            if (TicketFactory.sTicketPool.containsKey(key)) {
                System.out.println("使用缓存 ==> " + key);
                return TicketFactory.sTicketPool.get(key);
            }
            System.out.println("第一次查询,创建对象 ==> " + key);
            ITicket ticket = new TrainTicket(from, to);
            TicketFactory.sTicketPool.put(key, ticket);
            return ticket;
        }
    }
}

运行结果如下:

第一次查询,创建对象 ==> 深圳北->潮汕
深圳北->潮汕:硬座价格:429 元
使用缓存 ==> 深圳北->潮汕
深圳北->潮汕:软座价格:321 元
使用缓存 ==> 深圳北->潮汕
深圳北->潮汕:硬卧价格:481 元

可以看到,除了第一次查询创建对象后,后续查询相同车次票信息都是使用缓存对象,无需创建新对象了。

标签:享元,String,对象,模式,static,实训,东软,ticket
来源: https://blog.csdn.net/weixin_45607293/article/details/119052690