23种设计模式第二部分结构模式（7）享元模式

深藏阁楼爱情的钟 2022-07-17 00:29 142阅读 0赞

![57a92d42-4d84-3aa9-a8b9-63a0b02c2c36.jpg][]

## 理解 ##

享元（Flyweight）模式，顾名思义，和分享有关。享元模式可实现对象的共享，即共享池。

当对象多内存小，可以共享降低内存的开销，通常与工厂模式一起使用。

## 维基百科 ##

A flyweight is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory.

![f7aae0dd-b250-3829-bb07-49d87069bfbb.jpg][]

FlyWeightFactory负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，FlyWeight是超类。

适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库JDB连接来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。

## 实现 ##

public class ConnectionPool {  
          
        private Vector<Connection> pool;  
          
        /*公有属性*/  
        private String url = "jdbc:mysql://localhost:3306/test";  
        private String username = "root";  
        private String password = "root";  
        private String driverClassName = "com.mysql.jdbc.Driver";  
      
        private int poolSize = 100;  
        private static ConnectionPool instance = null;  
        Connection conn = null;  
      
        /*构造方法，做一些初始化工作*/  
        private ConnectionPool() {  
            pool = new Vector<Connection>(poolSize);  
      
            for (int i = 0; i < poolSize; i++) {  
                try {  
                    Class.forName(driverClassName);  
                    conn = DriverManager.getConnection(url, username, password);  
                    pool.add(conn);  
                } catch (ClassNotFoundException e) {  
                    e.printStackTrace();  
                } catch (SQLException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
      
        /* 返回连接到连接池 */  
        public synchronized void release() {  
            pool.add(conn);  
        }  
      
        /* 返回连接池中的一个数据库连接 */  
        public synchronized Connection getConnection() {  
            if (pool.size() > 0) {  
                Connection conn = pool.get(0);  
                pool.remove(conn);  
                return conn;  
            } else {  
                return null;  
            }  
        }  
    }

## 其他资料 ##

Flyweights are stored in a Factory's repository. The client restrains herself from creating Flyweights directly, and requests them from the Factory. Each Flyweight cannot stand on its own. Any attributes that would make sharing impossible must be supplied by the client whenever a request is made of the Flyweight. If the context lends itself to "economy of scale" (i.e. the client can easily compute or look-up the necessary attributes), then the Flyweight pattern offers appropriate leverage.

![Flyweight scheme][]

The `Ant`, `Locust`, and `Cockroach` classes can be "light-weight" because their instance-specific state has been de-encapsulated, or externalized, and must be supplied by the client.

![Flyweight scheme][Flyweight scheme 1]

Discussion. Trying to use objects at very low levels of granularity is nice, but the overhead may be prohibitive. Flyweight suggests removing the non-shareable state from the class, and having the client supply it when methods are called. This places more responsibility on the client, but, considerably fewer instances of the Flyweight class are now created. Sharing of these instances is facilitated by introducing a Factory class that maintains a "cache" of existing Flyweights.

class Gazillion {
       private static int num = 0;
       private int        row, col;
       public Gazillion( int maxPerRow ) {
          row = num / maxPerRow;
          col = num % maxPerRow;
          num++;
       }
       void report() {
          System.out.print( " " + row + col );
    }  }
    
    public class FlyweightDemo {
       public static final int ROWS = 6, COLS = 10;
    
       public static void main( String[] args ) {
          Gazillion[][] matrix = new Gazillion[ROWS][COLS];
          for (int i=0; i < ROWS; i++)
             for (int j=0; j < COLS; j++)
                matrix[i][j] = new Gazillion( COLS );
          for (int i=0; i < ROWS; i++) {
             for (int j=0; j < COLS; j++)
                matrix[i][j].report();
             System.out.println();
    }  }  }

Output

00 01 02 03 04 05 06 07 08 09
    10 11 12 13 14 15 16 17 18 19
    20 21 22 23 24 25 26 27 28 29
    30 31 32 33 34 35 36 37 38 39
    40 41 42 43 44 45 46 47 48 49
    50 51 52 53 54 55 56 57 58 59

In this refactoring, the "row" state is considered shareable (within each row anyways), and the "col" state has been externalized (it is supplied by the client when report() is called).

class Gazillion {
       private int row;
       public Gazillion( int theRow ) {
          row = theRow;
          System.out.println( "ctor: " + row );
       }
       void report( int theCol ) {
          System.out.print( " " + row + theCol );
    }  }
    
    class Factory {
       private Gazillion[] pool;
       public Factory( int maxRows ) {
          pool = new Gazillion[maxRows];
       }
       public Gazillion getFlyweight( int theRow ) {
          if (pool[theRow] == null)
             pool[theRow] = new Gazillion( theRow );
          return pool[theRow];
    }  }
    
    public class FlyweightDemo {
       public static final int ROWS = 6, COLS = 10;
    
       public static void main( String[] args ) {
          Factory theFactory = new Factory( ROWS );
          for (int i=0; i < ROWS; i++) {
             for (int j=0; j < COLS; j++)
                theFactory.getFlyweight( i ).report( j );
             System.out.println();
    }  }  }

Output

ctor: 0
     00 01 02 03 04 05 06 07 08 09
    ctor: 1
     10 11 12 13 14 15 16 17 18 19
    ctor: 2
     20 21 22 23 24 25 26 27 28 29
    ctor: 3
     30 31 32 33 34 35 36 37 38 39
    ctor: 4
     40 41 42 43 44 45 46 47 48 49
    ctor: 5
     50 51 52 53 54 55 56 57 58 59

[https://sourcemaking.com/design\_patterns/flyweight][https_sourcemaking.com_design_patterns_flyweight]

[57a92d42-4d84-3aa9-a8b9-63a0b02c2c36.jpg]: /images/20220717/5b63796d8b6146d6aebe2e24f78b2aae.png
[f7aae0dd-b250-3829-bb07-49d87069bfbb.jpg]: /images/20220717/f01c5ec057b94fccbc352efea5cc8755.png
[Flyweight scheme]: https://sourcemaking.com/files/v2/content/patterns/Flyweight1.svg
[Flyweight scheme 1]: https://sourcemaking.com/files/v2/content/patterns/Flyweight_1.svg
[https_sourcemaking.com_design_patterns_flyweight]: https://sourcemaking.com/design_patterns/flyweight