Cara menggunakan corak reka bentuk flyweight Java untuk mengoptimumkan penciptaan objek dan meningkatkan prestasi dan kecekapan

Pengenalan

Corak Flyweight di Java ialah corak reka bentuk struktur yang bertujuan untuk mengurangkan penggunaan memori dan meningkatkan prestasi dengan berkongsi seberapa banyak objek yang mungkin.

Mod flyweight Java biasanya termasuk yang berikut 4 peranan

• Flyweight Factory: Bertanggungjawab untuk mencipta dan mengurus objek flyweight.

• Concrete Flyweight (Concrete Flyweight): melaksanakan antara muka flyweight dan menyimpan keadaan dalaman yang berkaitan dengan keadaan dikongsi.

  Keadaan Tidak Dikongsi: Menyimpan keadaan objek flyweight yang tidak dikongsi.

• Nota: Peranan keadaan flyweight dan bukan kongsi abstrak adalah pilihan, ia boleh diabaikan untuk menggabungkan fungsinya ke dalam peranan lain
• Apabila pelanggan meminta untuk mencipta atau mengakses objek flyweight, kilang flyweight menyemak sama ada objek flyweight telah dibuat Objek Jika ia telah dibuat, rujukan kepada objek sedia ada akan dikembalikan belum dicipta, objek baharu dicipta dan rujukannya dikembalikan Dengan cara ini, pelanggan boleh berkongsi objek sedia ada tanpa perlu mencipta objek baharu, dengan itu mengurangkan penggunaan memori dan meningkatkan Prestasi.
  Pelaksanaan
<.> Ambil maklumat produk dalam e-dagang sebagai contoh Dalam e-dagang, setiap produk mempunyai nama, harga, inventori dan atribut lain Biasanya, setiap produk perlu mencipta objek yang berasingan, yang akan meningkatkan penggunaan memori. dan jika produk yang sama dibeli beberapa kali, sistem akan mencipta berbilang objek yang sama, membazir sumber.

Berat terbang abstrak

public interface Product {
    String getName();
    double getPrice();
    int getStock();
}

Berat terbang khusus

public class ConcreteProduct implements Product{
    private String name;
    private double price;
    private int stock;
    public ConcreteProduct(String name, double price, int stock) {
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public double getPrice() {
        return price;
    }
    @Override
    public int getStock() {
        return stock;
    }
}

kilang flyweight

public class ProductFactory {
    private static Map<String, Product> productMap = new HashMap<>();
    public static Product getProduct(String name, double price, int stock) {
        String key = name + "_" + price;
        Product res = productMap.get(key);
        if (Objects.isNull(res)) {
            // 如果缓存池内不存在,就创建新对象放置到缓存池
            res = new ConcreteProduct(name, price, stock);
            productMap.put(key, res);
        }
        return res;
    }
}

Ujian

public class Demo {
    public static void main(String[] args) {
        Product p1 = ProductFactory.getProduct("iPhone 14 Plus", 8899, 1);
        Product p2 = ProductFactory.getProduct("iPhone 14 Plus", 8899, 1);
        System.out.println(p1 == p2);
    }
}

Dalam kod sampel di atas, mula-mula buat antara muka produk, yang mengandungi nama, harga, inventori dan atribut lain produk Kemudian buat kelas produk tertentu ConcreteProduct, laksanakan antara muka Produk, dan tentukan nama keadaan dalaman yang dikongsi, harga dan stok Seterusnya kami mencipta ProductFactory untuk Cipta dan uruskan objek produk yang dikongsi objek produk. Setiap kali pelanggan perlu membeli produk, kami mula-mula menyemak sama ada objek produk telah dicipta, kembalikan rujukan kepada objek yang sedia ada, buat objek baharu dan simpan ia dalam HashMap dan kembalikan rujukannya.

Dengan berkongsi objek, hanya satu salinan objek yang sama dalam sistem boleh wujud dalam ingatan, dengan itu mengurangkan overhed memori.

Meningkatkan skalabiliti sistem. Jika anda perlu menambah objek baharu, anda hanya perlu menciptanya di kilang tanpa mengubah suai kod asal.

Tingkatkan keselamatan sistem Dikongsi objek dibaca-. sahaja dan tidak akan diubah suai.

• Kelemahan

• boleh menyebabkan sistem menjadi terlalu rumit dan meningkatkan kerumitan kod.

• Kerja tambahan diperlukan untuk mengekalkan konsistensi objek yang dikongsi, seperti keselamatan benang dan isu lain perlu dipertimbangkan.

• Kewujudan objek kongsi mungkin mengurangkan fleksibiliti program, seperti ketidakupayaan untuk memperibadikan objek kongsi.

Senario aplikasi

• Apabila terdapat besar bilangan objek yang sama atau serupa dalam sistem, anda boleh mempertimbangkan untuk menggunakan mod flyweight untuk mengurangkan overhed memori.

• Apabila objek perlu dicache dan boleh digunakan semula , anda juga boleh mempertimbangkan untuk menggunakan mod flyweight.

• Dalam persekitaran berbilang benang, anda boleh menggunakan mod flyweight untuk berkongsi objek dan meningkatkan prestasi serentak program.

Dalam pembangunan permainan, anda boleh menggunakan model flyweight untuk mengurus objek seperti watak dalam permainan.

Atas ialah kandungan terperinci Cara menggunakan corak reka bentuk flyweight Java untuk mengoptimumkan penciptaan objek dan meningkatkan prestasi dan kecekapan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!