feat: 享元模式

README/设计模式-v2.md

@@ -1358,19 +1358,77 @@ public class Composite {
 
 ## 享元模式---结构型
 
----
+享元模式（Flyweight Pattern）是一种结构型设计模式，它的主要目的是通过共享对象来减少内存使用和提高性能。在享元模式中，系统中可能会有很多重复的对象，而享元模式通过将这些对象分为“共享部分”和“非共享部分”，只在共享部分创建单一实例，来优化内存使用。
+
+![image-20250204191157193](./images/设计模式-v2/image-20250204191157193.png)
+
+**需要角色**
+
+**Flyweight（享元类）**：负责实现共享的对象部分，通常是不可变的状态。它是享元模式的核心，通过共享相同的状态，减少内存消耗。
+
+**ConcreteFlyweight（具体享元类）**：是Flyweight的具体实现，负责实现具体的共享对象。具体享元类一般会包含一个外部状态，它并不存储该状态，而是通过外部传入的方式进行变化。
+
+**FlyweightFactory（享元工厂类）**：是一个工厂，负责管理共享的享元对象。在客户端请求享元对象时，它会从池中查找是否已有实例，如果有则返回，若没有则创建新的享元对象并将其返回。
+
+**Client（客户端）**：负责根据外部状态请求享元对象。客户端会传递外部状态（不共享的部分）给享元对象，而享元对象则只关注内部共享部分。
+
+### 简单示例
+
+#### 示例代码
+
+```java
+public class FlyWeight {
+    public static void main(String[] args) {
+        // 第一次获取对象会进行资源创建
+        GirlFriend girlFriend1 = GirlFriendFactory.getGirlFriend("第一个女朋友");
+        GirlFriend girlFriend2 = GirlFriendFactory.getGirlFriend("第二个女朋友");
+
+        // 第二次获取对象直接从容器中获取
+        GirlFriend girlFriend11 = GirlFriendFactory.getGirlFriend("第一个女朋友");
+        GirlFriend girlFriend22 = GirlFriendFactory.getGirlFriend("第二个女朋友");
+
+        System.out.println(girlFriend1 == girlFriend11);// true
+        System.out.println(girlFriend2 == girlFriend22);// true
+    }
+
+    @Data
+    static class GirlFriend {
+        private String name;
+        private Integer age;
+    }
+
+    static class GirlFriendFactory {
+        private static final Map<String, GirlFriend> map = new HashMap<>();
+
+        public static GirlFriend getGirlFriend(String name) {
+            GirlFriend girlFriend = map.get(name);
+            if (girlFriend == null) {
+                girlFriend = new GirlFriend();
+                girlFriend.name = name;
+                map.put(name, girlFriend);
+            }
+            return girlFriend;
+        }
+    }
+}
+```
+
+#### 运行结果：
+
+```java
+true
+true
+```
 
 ## 代理模式---结构型
 
-### 静态代理
+### 静态代理-1
 
 ![image-20250204185312828](./images/设计模式-v2/image-20250204185312828.png)
 
-如果是静态代理，做Java开发几乎都在用，就是抽象接口和实现，比如：`UserService`之后`UserServiceImpl`实现`UserService`，就是这个。
+如果是静态代理，做Java开发几乎都在用，就是抽象接口和实现，比如：`UserService`之后`UserServiceImpl`实现`UserService`，就是这个，之后使用`UserService`进行调用实现中的方法。
 
-之后使用`UserService`进行调用实现中的方法，所以做过后端开发这个没有什么必要说的；真要说就是动态代理。
+### 静态代理-2
-
-### 动态代理
 
 ![image-20250204185852710](./images/设计模式-v2/image-20250204185852710.png)
 

pattern/src/main/java/cn/bunny/pattern18/FlyWeight.java

@@ -0,0 +1,41 @@
+package cn.bunny.pattern18;
+
+import lombok.Data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FlyWeight {
+    public static void main(String[] args) {
+        // 第一次获取对象会进行资源创建
+        GirlFriend girlFriend1 = GirlFriendFactory.getGirlFriend("第一个女朋友");
+        GirlFriend girlFriend2 = GirlFriendFactory.getGirlFriend("第二个女朋友");
+
+        // 第二次获取对象直接从容器中获取
+        GirlFriend girlFriend11 = GirlFriendFactory.getGirlFriend("第一个女朋友");
+        GirlFriend girlFriend22 = GirlFriendFactory.getGirlFriend("第二个女朋友");
+
+        System.out.println(girlFriend1 == girlFriend11);// true
+        System.out.println(girlFriend2 == girlFriend22);// true
+    }
+
+    @Data
+    static class GirlFriend {
+        private String name;
+        private Integer age;
+    }
+
+    static class GirlFriendFactory {
+        private static final Map<String, GirlFriend> map = new HashMap<>();
+
+        public static GirlFriend getGirlFriend(String name) {
+            GirlFriend girlFriend = map.get(name);
+            if (girlFriend == null) {
+                girlFriend = new GirlFriend();
+                girlFriend.name = name;
+                map.put(name, girlFriend);
+            }
+            return girlFriend;
+        }
+    }
+}