FlyWeight - Patrones de diseño
El modo Flyweight se usa principalmente para reducir la cantidad de objetos creados para reducir el uso de memoria y mejorar el rendimiento. Este tipo de patrón de diseño es un patrón estructural que proporciona una manera de reducir la cantidad de objetos y, por lo tanto, mejorar la estructura de objetos requerida por la aplicación.
Directorio de artículos
¿Qué es el modelo de peso mosca?
Modo Flyweight, compartir es compartir, elemento es objeto , y la comprensión popular del modo Flyweight es realizar el intercambio de objetos que se usan muchas veces a través de medios específicos, para reducir el uso de memoria y mejorar el rendimiento.
Oye, no suena como un patrón singleton, pero no lo es,El patrón singleton es compartir solo un objeto, y el patrón flyweight es compartir varios objetos con una sola instancia, y estas instancias tienen las mismas características de estado.
La estructura del patrón de peso mosca.
En general, implementar el patrón Flyweight requiere que se implementen las siguientes partes:
-
Clase abstracta de peso mosca
La superclase o interfaz de todas las clases de peso mosca concretas, a través de la cual Flyweight puede aceptar y actuar sobre estados externos. -
La clase ConcreteFlyweight
hereda la superclase Flyweight o implementa la interfaz Flyweight y agrega espacio de almacenamiento para su estado interno. -
Clase FlyweightFactory
Una fábrica de peso mosca utilizada para crear y administrar objetos Flyweight, principalmente para garantizar un intercambio razonable de Flyweights. Cuando un usuario solicita un Flyweight, el objeto FlyweightFactory proporciona una instancia creada o crea una instancia. -
Cliente
La clase utilizada para realizar operaciones de prueba. -
La clase de estado externo (como la clase de usuario)
generalmente se divide en estado interno y estado externo en el patrón de peso ligero. El estado interno es la parte que se puede compartir, y el estado externo se refiere a una marca de la que el objeto puede depender, es un estado que cambia con el entorno y no se puede compartir. -
Diagrama de clase esquemático
Demostración de caso
Si hay un artículo en un sitio web ahora, debe publicarse a través de noticias, blog, subprograma WeChat y otros canales, pero los usuarios que leen estos artículos no son solo una persona, y los canales de lectura también son diferentes, por lo que hacemos not Cuando un usuario crea un sitio web o blog, solo necesitamos crear un canal para que otros usuarios compartan de acuerdo con el uso específico del usuario.
Pasos de implementación
Al definir un conjunto en Flyweight Factory, se realiza la tecnología del grupo de objetos. Si el usuario necesita un objeto específico, primero determine si existe en el grupo. Si existe, se puede tomar directamente del grupo de objetos para su uso; esto El objeto se crea y se agrega al conjunto de objetos para mayor comodidad.
demostración de código
Sitio web de la clase principal de Flyweight
package com.design_patterns.flyweight;
//享元类的父类WebSite
public abstract class WebSite {
//定义抽象方法
public abstract void use(User user);
}
Clase de peso mosca de hormigón ConcreteWebSite
package com.design_patterns.flyweight;
public class ConcreteWebSite extends WebSite {
private String type = ""; //网站发布的形式(类型)
private User user = null;
//构造方法
public ConcreteWebSite(String type){
this.type = type;
}
@Override
public void use(User user) {
setUser(user);
System.out.println("网站发布的形式为" + type +
"---->使用者(" + user.getName() + ")");
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
Clase de fábrica de peso mosca WebSiteFactory
package com.design_patterns.flyweight;
import java.util.HashMap;
/**
* 网站工厂类, 根据需求返回一个具体的网站
*/
public class WebSiteFactory {
private HashMap<String,ConcreteWebSite> pool = new HashMap<String, ConcreteWebSite>();
/**
* 根据网站的类型，返回一个网站，如果没有就创建一个网站，并放入到池中，并返回
* @param type
* @return
*/
public WebSite getWebSiteCategory(String type){
if(!pool.containsKey(type)){
//就创建一个网站，并将其放入池中
pool.put(type,new ConcreteWebSite(type));
}
return (WebSite)pool.get(type);
}
/**
* 获取网站分类的总数
* （池中有多少个网站类型）
* @return
*/
public int getWebSiteCount(){
return pool.size();
}
}
Usuario de clase de estado externo
package com.design_patterns.flyweight;
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Cliente de clase de prueba Cliente
package com.design_patterns.flyweight;
public class Client {
public static void main(String[] args) {
//创建一个工厂
WebSiteFactory webSiteFactory = new WebSiteFactory();
//客户要一个以新闻形式发布的网站
WebSite webSite = webSiteFactory.getWebSiteCategory("新闻");
//客户要一个以博客形式发布的网站
WebSite webSite1 = webSiteFactory.getWebSiteCategory("博客");
//客户要一个以博客形式发布的网站
WebSite webSite2 = webSiteFactory.getWebSiteCategory("博客");
//客户要一个以微信小程序形式发布的网站
WebSite webSite3 = webSiteFactory.getWebSiteCategory("微信小程序");
//客户要一个以微信小程序形式发布的网站
WebSite webSite4 = webSiteFactory.getWebSiteCategory("微信小程序");
//客户要一个以微信小程序形式发布的网站
WebSite webSite5 = webSiteFactory.getWebSiteCategory("微信小程序");
webSite.use(new User("Tom"));
webSite1.use(new User("tom"));
webSite2.use(new User("Jack"));
webSite3.use(new User("jack"));
webSite4.use(new User("HaHa"));
webSite5.use(new User("XiXi"));
System.out.println("\n网站的分类共---->" + webSiteFactory.getWebSiteCount() + "个");
}
}
Resumir
Flyweight usa objetos compartidos para minimizar el uso de memoria y compartir información con tantos objetos similares como sea posible; es adecuado para una gran cantidad de objetos que usan una cantidad inaceptablemente grande de memoria simplemente debido a la repetición .
Bueno, compartamos el estado interno y distingamos el estado externo independiente . Este es el modo Flyweight. Vamos, amigos ~~~