享元模式分析与实践

news2024/9/23 9:27:29

享元就是共享单元（元素）的意思。单元代表了整体的部分，如果一个对象其中的部分是稳定的不会改变的，那么这个部分即可以共享。享元模式的用途就是复用对象的单元，让对象的节省内存。

一、享元模式与单例模式区别

单例模式是类级别的，一个类只能有一个对象实例；
享元模式是对象级别的，可以有多个对象实例，多个变量引用同一个对象实例；
享元模式主要是为了节约内存空间，提高系统性能，而单例模式主要为了可以共享数据；

1、优点

（1）节省内存空间，对于可重复的对象只会被创建一次，对象比较多时，就会极大的节省空间。

（2）提高效率，由于创建对象的数量减少，所以对系统内存的需求也减小，使得速度更快，效率更高。

2、缺点

提高了系统复杂性，需要分离出外部状态（k）和内部状态(v)，而且外部状态具有固化特性，不应该随内部状态改变而改变，否则导致系统的逻辑混乱，为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。

● 内部状态

内部状态是对象可共享出来的信息，存储在享元对象内部并且不会随环境改变而改变，它们可以作为一个对象的动态附加信息，不必直接储存在具体某个对象中，属于可以共享的部分。

● 外部状态

外部状态是对象得以依赖的一个标记，是随环境改变而改变的、不可以共享的状态，它是一批对象的统一标识，是唯一的一个索引值。

二、享元模式与单例模式代码举例

1.1单例模式代码

public class Singleton {
    // 我来写一个单例模式  懒汉式
    private static Singleton singleton;
    private Singleton(){}
    
    public static synchronized Singleton getSingleton(){
        if(singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getSingleton();
        Singleton instance2 = Singleton.getSingleton();
        System.out.println(instance1==instance2);
    }
}

1.2享元模式代码

定义抽象享元类

/**
 * 定义抽象享元类
 */
public abstract class Book {

    /**
     * 外部状态 书名
     */
    public String name;

    public Book(String name) {
        this.name = name;
    }

    /**
     * 借书动作
     */
    public abstract void borrow();
}

定义具体享元类

/**
 * 定义具体享元类
 */
public class ConcreteBook extends Book {

    /**
     * 被借出的书名
     */
    public ConcreteBook(String name){
        super(name);
    }

    @Override
    public void borrow() {
        System.out.println("借了一本书名为："+this.name);
    }
}

享元工厂

/**
 * 享元工厂
 */
public class LibraryFactory {

    /**
     * 图书馆维护一个图书列表
     */
    private Map<String, Book> bookPools = new HashMap<>();

    private static LibraryFactory factory = new LibraryFactory();

    /**
     * 图书馆只有一个
     */
    public static LibraryFactory getInstance() {
        return factory;
    }

    /**
     * 图书馆外借图书
     */
    public Book libToBorrow(String bookName) {
        Book order;
        //如果书架有书，直接借出
        if (bookPools.containsKey(bookName)) {
            order = bookPools.get(bookName);
        } else {
            //如果没有,那就拿本新书
            //根据外部状态创建享元对象
            order = new ConcreteBook(bookName);
            //放到池中
            bookPools.put(bookName, order);
        }
        return order;
    }

    //书架上书的数量
    public int getAllBookSize() {
        return bookPools.size();
    }
}

控制层

@RestController
@RequestMapping("/studentController")
public class StudentController {

    //图书馆书架上的书
    private static List<Book> books = new ArrayList<Book>();
    private static LibraryFactory libraryFactory;

    // 查询
    @PostMapping("/borrow")
    @ResponseBody
    public void borrow() {
        libraryFactory = LibraryFactory.getInstance();
        studentBorrow("葵花宝典");
        studentBorrow("僻邪剑谱");
        studentBorrow("java从入门到放弃");
        //把每一本书借出去
        for (Book book : books) {
            book.borrow();
        }
        System.out.println("后两本秘籍没学会，又借了一次 ");
        studentBorrow("僻邪剑谱");
        studentBorrow("java从入门到放弃");
        Book 僻邪剑谱 = libraryFactory.libToBorrow("僻邪剑谱");
        僻邪剑谱.borrow();
        Book java从入门到放弃 = libraryFactory.libToBorrow("java从入门到放弃");
        java从入门到放弃.borrow();

        //输出一些学生一共借多少本书
        System.out.println("学生一共借了 " + books.size() + " 本书! ");
        //输出一下图书馆一共借出多少本书
        System.out.println("图书馆实际借出" + libraryFactory.getAllBookSize() + " 本书");
    }

    private static void studentBorrow(String bookName) {
        books.add(libraryFactory.libToBorrow(bookName));
    }
}