1. Introdução

Na programação, às vezes nos deparamos com o cenário de criação de um grande número de instâncias de objetos iguais ou semelhantes, como as peças pretas e brancas do jogo Go, e as carteiras e cadeiras da sala de aula. Se locais semelhantes forem abstraídos e compartilhados, isso pode economizar muitos recursos do sistema e melhorar o desempenho do sistema, o que corresponde ao modo Flyweight.

2 Definições

Padrão Flyweight: Use técnicas de compartilhamento para oferecer suporte eficiente à reutilização de um grande número de objetos refinados. Ele reduz bastante o número de objetos que precisam ser criados pelo compartilhamento de objetos existentes e evita a sobrecarga de um grande número de classes semelhantes, melhorando assim a utilização dos recursos do sistema.

3 Estado interno e estado externo

O estado interno refere-se às informações compartilhadas no Flyweight, como cadeiras de sala de aula, cujo material, forma, especificação e estrutura são todos iguais e podem ser totalmente compartilhados.

O estado externo refere-se a informações que o Flyweight não pode compartilhar, e essas informações mudarão conforme o ambiente muda, como o usuário atual das mesas e cadeiras da sala de aula.

4 Estrutura e Implementação

O modo Flyweight contém 4 funções importantes, a saber:

1. A função abstrata FlyWeight é a classe base de todas as classes específicas Flyweight, e é a interface pública que as especificações Flyweight específicas precisam implementar.Estados externos não Flyweight são passados através de métodos na forma de parâmetros.

2. Função Flyweight concreto: Implemente a interface especificada na função Flyweight abstrata.

3. Função Flyweight não compartilhável: É um estado externo que não pode ser compartilhado, sendo injetado nos métodos relevantes de Flyweight específico na forma de parâmetros.

4. Função Flyweight Factory: responsável por criar e gerenciar funções Flyweight. Quando um objeto cliente solicita um objeto flyweight, a fábrica flyweight verifica se existe um objeto flyweight que atende aos requisitos do sistema e, caso exista, é fornecido ao cliente; caso não exista, um novo objeto flyweight é criado.

A estrutura é mostrada na figura a seguir (a figura é da referência 2):

5 vantagens e desvantagens

A principal vantagem do padrão Flyweight é que apenas uma cópia do mesmo objeto é salva, o que reduz o número de objetos no sistema, reduzindo assim a pressão na memória causada por objetos refinados no sistema.

Suas principais desvantagens são:

1. Para tornar os objetos compartilháveis, alguns estados que não podem ser compartilhados precisam ser externalizados, o que aumentará a complexidade do programa.

2. Ler o estado externo do Flyweight tornará o tempo de execução um pouco mais longo.

6 Exemplos de Código

Para o mesmo site, não precisamos criar objetos de instância diferentes, apenas usar usuários diferentes e usuários diferentes para a mesma instância.

6.1 Definir Usuário Usuário

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-10-22 15:23
 **/
@Data
@AllArgsConstructor
public class User {
    /**
     * 用户名
     */
    private String name;

    /**
     * 简介
     */
    private String desc;

}

6.2 Site Resumo Flyweight

**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-10-22 11:28
 * @desc: 抽象享元接口
 **/
public interface Website {

    /**
     * 发布博客
     * @param user 用户
     */
    void postBlog(User user);


    /**
     * 上传图片
     * @param user 用户
     */
    void uploadPicture(User user);
}

6.3 Site do Concrete Flyweight Concrete

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-10-22 15:22
 **/
public class ConcreteWebsite implements Website{

    @Override
    public void postBlog(User user) {
        System.out.println(MessageFormat.format("{0}用户，简介是{1}，上传博客", user.getName(), user.getDesc()));
    }

    @Override
    public void uploadPicture(User user) {
        System.out.println(MessageFormat.format("{0}用户，简介是{1}，上传图片", user.getName(), user.getDesc()));
    }
}

6.4 Fábrica

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-10-22 15:28
 **/
public class Factory {
    private Map<String, Website> websites = new HashMap<>();


    public  Website getWebsite(String key){
        if (websites.containsKey(key)){
            return websites.get(key);
        }
        Website website = new ConcreteWebsite();
        websites.put(key, website);
        return website;
    }
}

6.5 Programa principal

/**
 * @program: design-pattern-learning
 * @author: zgr
 * @create: 2021-10-22 11:27
 **/
public class MainClass {
    public static void main(String[] args) {
        Factory factory = new Factory();
        Website website11 = factory.getWebsite("csdn");
        Website website12 = factory.getWebsite("csdn");
        Website website21 = factory.getWebsite("zhihu");
        Website website22 = factory.getWebsite("zhihu");

        website11.postBlog(new User("张三", "助理工程师"));
        website11.uploadPicture(new User("张三", "助理工程师"));
        website12.postBlog(new User("李四", "中级工程师"));
        website12.uploadPicture(new User("李四", "中级工程师"));

        website21.postBlog(new User("王五", "副高级工程师"));
        website21.uploadPicture(new User("王五", "副高级工程师"));
        website22.postBlog(new User("赵六", "高级工程师"));
        website22.uploadPicture(new User("赵六", "高级工程师"));
    }
}

6.6 Resultados corridos

7 Cotações

1 "Padrões de Design Dahua"

2 Modo Flyweight (versão detalhada)

8 Código fonte

https://github.com/airhonor/design-pattern-learning/tree/main/src/com/hz/design/pattern/flyweight

Padrão de design --- padrão FlyWeight