Skip to content

Commit 2207ea4

Browse files
sudowandererMikeohbus
authored
Translation zh (iluwatar#1646)
* add state and callback pattern * add command and template-method pattern * add iterator pattern * add bridege and DI pattern * fix issue iluwatar#1600 * add converter,proxy,visitor pattern * add caching,composite,delegation,dirty-flag,interpreter patterns * add dao and producer-consumer * add dto and provate class data pattern * fix iluwatar#1646 png path problems * fix iluwatar#1646 composite png path case problem Co-authored-by: Mike <[email protected]> Co-authored-by: Subhrodip Mohanta <[email protected]>
1 parent 934578d commit 2207ea4

File tree

14 files changed

+1204
-2
lines changed

14 files changed

+1204
-2
lines changed

‎zh/caching/README.md

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
---
2+
layout: pattern
3+
title: Caching
4+
folder: caching
5+
permalink: /patterns/caching/
6+
categories: Behavioral
7+
tags:
8+
- Performance
9+
- Cloud distributed
10+
---
11+
12+
## 目的
13+
为了避免昂贵的资源重新获取，方法是在资源使用后不立即释放资源。资源保留其身份，保留在某些快速访问的存储中，并被重新使用，以避免再次获取它们。
14+
15+
## 类图
16+
![alt text](../../caching/etc/caching.png "Caching")
17+
18+
## 适用性
19+
在以下情况下使用缓存模式
20+
21+
* 重复获取，初始化和释放同一资源会导致不必要的性能开销。
22+
23+
## 鸣谢
24+
25+
* [Write-through, write-around, write-back: Cache explained](http://www.computerweekly.com/feature/Write-through-write-around-write-back-Cache-explained)
26+
* [Read-Through, Write-Through, Write-Behind, and Refresh-Ahead Caching](https://docs.oracle.com/cd/E15357_01/coh.360/e15723/cache_rtwtwbra.htm#COHDG5177)
27+
* [Cache-Aside pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/cache-aside)

‎zh/composite/README.md

+174
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,174 @@
1+
---
2+
layout: pattern
3+
title: Composite
4+
folder: composite
5+
permalink: /patterns/composite/
6+
categories: Structural
7+
tags:
8+
- Gang of Four
9+
---
10+
11+
## 目的
12+
13+
将对象组合成树结构以表示部分整体层次结构。 组合可以使客户统一对待单个对象和组合对象。
14+
15+
## 解释
16+
17+
真实世界例子
18+
19+
> 每个句子由单词组成，单词又由字符组成。这些对象中的每一个都是可打印的，它们可以在它们之前或之后打印一些内容，例如句子始终以句号结尾，单词始终在其前面有空格。
20+
21+
通俗的说
22+
23+
> 组合模式使客户能够以统一的方式对待各个对象。
24+
25+
维基百科说
26+
27+
> 在软件工程中，组合模式是一种分区设计模式。组合模式中，一组对象将像一个对象的单独实例一样被对待。组合的目的是将对象“组成”树状结构，以表示部分整体层次结构。实现组合模式可使客户统一对待单个对象和组合对象。
28+
29+
**程序示例**
30+
31+
使用上面的句子例子。 这里我们有基类`LetterComposite`和不同的可打印类型`Letter`，`Word`和`Sentence`。
32+
33+
```java
34+
public abstract class LetterComposite {
35+
36+
private final List<LetterComposite> children = new ArrayList<>();
37+
38+
public void add(LetterComposite letter) {
39+
children.add(letter);
40+
}
41+
42+
public int count() {
43+
return children.size();
44+
}
45+
46+
protected void printThisBefore() {
47+
}
48+
49+
protected void printThisAfter() {
50+
}
51+
52+
public void print() {
53+
printThisBefore();
54+
children.forEach(LetterComposite::print);
55+
printThisAfter();
56+
}
57+
}
58+
59+
public class Letter extends LetterComposite {
60+
61+
private final char character;
62+
63+
public Letter(char c) {
64+
this.character = c;
65+
}
66+
67+
@Override
68+
protected void printThisBefore() {
69+
System.out.print(character);
70+
}
71+
}
72+
73+
public class Word extends LetterComposite {
74+
75+
public Word(List<Letter> letters) {
76+
letters.forEach(this::add);
77+
}
78+
79+
public Word(char... letters) {
80+
for (char letter : letters) {
81+
this.add(new Letter(letter));
82+
}
83+
}
84+
85+
@Override
86+
protected void printThisBefore() {
87+
System.out.print(" ");
88+
}
89+
}
90+
91+
public class Sentence extends LetterComposite {
92+
93+
public Sentence(List<Word> words) {
94+
words.forEach(this::add);
95+
}
96+
97+
@Override
98+
protected void printThisAfter() {
99+
System.out.print(".");
100+
}
101+
}
102+
```
103+
104+
然后我们有一个消息携带者来携带消息。
105+
106+
```java
107+
public class Messenger {
108+
109+
LetterComposite messageFromOrcs() {
110+
111+
var words = List.of(
112+
new Word('W', 'h', 'e', 'r', 'e'),
113+
new Word('t', 'h', 'e', 'r', 'e'),
114+
new Word('i', 's'),
115+
new Word('a'),
116+
new Word('w', 'h', 'i', 'p'),
117+
new Word('t', 'h', 'e', 'r', 'e'),
118+
new Word('i', 's'),
119+
new Word('a'),
120+
new Word('w', 'a', 'y')
121+
);
122+
123+
return new Sentence(words);
124+
125+
}
126+
127+
LetterComposite messageFromElves() {
128+
129+
var words = List.of(
130+
new Word('M', 'u', 'c', 'h'),
131+
new Word('w', 'i', 'n', 'd'),
132+
new Word('p', 'o', 'u', 'r', 's'),
133+
new Word('f', 'r', 'o', 'm'),
134+
new Word('y', 'o', 'u', 'r'),
135+
new Word('m', 'o', 'u', 't', 'h')
136+
);
137+
138+
return new Sentence(words);
139+
140+
}
141+
142+
}
143+
```
144+
145+
然后它可以这样使用:
146+
147+
```java
148+
var orcMessage = new Messenger().messageFromOrcs();
149+
orcMessage.print(); // Where there is a whip there is a way.
150+
var elfMessage = new Messenger().messageFromElves();
151+
elfMessage.print(); // Much wind pours from your mouth.
152+
```
153+
154+
## 类图
155+
156+
![alt text](../../composite/etc/composite.urm.png "Composite class diagram")
157+
158+
## 适用性
159+
160+
使用组合模式当
161+
162+
* 你想要表示对象的整体层次结构
163+
* 你希望客户能够忽略组合对象和单个对象之间的差异。 客户将统一对待组合结构中的所有对象。
164+
165+
## 真实世界例子
166+
167+
* [java.awt.Container](http://docs.oracle.com/javase/8/docs/api/java/awt/Container.html) and [java.awt.Component](http://docs.oracle.com/javase/8/docs/api/java/awt/Component.html)
168+
* [Apache Wicket](https://github.com/apache/wicket) component tree, see [Component](https://github.com/apache/wicket/blob/91e154702ab1ff3481ef6cbb04c6044814b7e130/wicket-core/src/main/java/org/apache/wicket/Component.java) and [MarkupContainer](https://github.com/apache/wicket/blob/b60ec64d0b50a611a9549809c9ab216f0ffa3ae3/wicket-core/src/main/java/org/apache/wicket/MarkupContainer.java)
169+
170+
## 鸣谢
171+
172+
* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
173+
* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
174+
* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)

‎zh/converter/README.md

+101
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,101 @@
1+
---
2+
layout: pattern
3+
title: Converter
4+
folder: converter
5+
permalink: /patterns/converter/
6+
categories: Creational
7+
tags:
8+
- Decoupling
9+
---
10+
11+
## 目的
12+
13+
转换器模式的目的是提供相应类型之间双向转换的通用方法，允许进行干净的实现，而类型之间无需相互了解。此外，Converter模式引入了双向集合映射，从而将样板代码减少到最少。
14+
15+
## 解释
16+
17+
真实世界例子
18+
19+
> 在真实的应用中经常有这种情况，数据库层包含需要被转换成业务逻辑层DTO来使用的实体。对于潜在的大量类进行类似的映射，我们需要一种通用的方法来实现这一点。
20+
21+
通俗的说
22+
23+
> 转换器模式让一个类的实例映射成另一个类的实例变得简单
24+
25+
**程序示例**
26+
27+
我们需要一个通用的方案来解决映射问题。让我们来介绍一个通用的转换器。
28+
29+
```java
30+
public class Converter<T, U> {
31+
32+
private final Function<T, U> fromDto;
33+
private final Function<U, T> fromEntity;
34+
35+
public Converter(final Function<T, U> fromDto, final Function<U, T> fromEntity) {
36+
this.fromDto = fromDto;
37+
this.fromEntity = fromEntity;
38+
}
39+
40+
public final U convertFromDto(final T dto) {
41+
return fromDto.apply(dto);
42+
}
43+
44+
public final T convertFromEntity(final U entity) {
45+
return fromEntity.apply(entity);
46+
}
47+
48+
public final List<U> createFromDtos(final Collection<T> dtos) {
49+
return dtos.stream().map(this::convertFromDto).collect(Collectors.toList());
50+
}
51+
52+
public final List<T> createFromEntities(final Collection<U> entities) {
53+
return entities.stream().map(this::convertFromEntity).collect(Collectors.toList());
54+
}
55+
}
56+
```
57+
58+
专属的转换器像下面一样从基类继承。
59+
60+
```java
61+
public class UserConverter extends Converter<UserDto, User> {
62+
63+
public UserConverter() {
64+
super(UserConverter::convertToEntity, UserConverter::convertToDto);
65+
}
66+
67+
private static UserDto convertToDto(User user) {
68+
return new UserDto(user.getFirstName(), user.getLastName(), user.isActive(), user.getUserId());
69+
}
70+
71+
private static User convertToEntity(UserDto dto) {
72+
return new User(dto.getFirstName(), dto.getLastName(), dto.isActive(), dto.getEmail());
73+
}
74+
75+
}
76+
```
77+
78+
现在，在User和UserDto之间的映射变得轻而易举。
79+
80+
```java
81+
var userConverter = new UserConverter();
82+
var dtoUser = new UserDto("John", "Doe", true, "whatever[at]wherever.com");
83+
var user = userConverter.convertFromDto(dtoUser);
84+
```
85+
86+
## 类图
87+
88+
![alt text](../../converter/etc/converter.png "Converter Pattern")
89+
90+
## 适用性
91+
92+
在下面这些情况下使用转换器模式：
93+
94+
* 如果你的类型在逻辑上相互对应，并需要在它们之间转换实体
95+
* 当你想根据上下文提供不同的类型转换方式时
96+
* 每当你引入DTO（数据传输对象）时你可能都需要将其转换为
97+
DO
98+
99+
## 鸣谢
100+
101+
* [Converter](http://www.xsolve.pl/blog/converter-pattern-in-java-8/)

0 commit comments

Comments
 (0)