Prototype mode
What is the prototype pattern
Now there is a scenario, that is, many queries or business processing. The parameters accepted by the back end are encapsulated in one object. The processing business calls different processing services. Each processing service may modify the value in the parameter object, so each service needs to pass a new parameter object. At this time, you need to create a new parameter object without calling a service, In order to ensure better performance, it is necessary to quickly create new objects with the same values. The prototype mode is a good choice and belongs to the creation mode.
Simply put, specify the kind of objects to be created, and create new objects by copying these prototypes.
Example:
1. Define objects that can be cloned
If a class implements the clonable interface, it can be cloned. Isn't it very simple.
/** * After implementing the clonable interface, you can clone the Object using the clone() method of the Object */ class ProductWithClone implements Cloneable{ private String name; private int age; private String address; public ProductWithClone(String name, int age, String address) { this.name = name; this.age = age; this.address = address; } public String getName() { return name; } public void setName(String name) { this.name = name; } /** * jvm The object attribute is copied * @return * @throws CloneNotSupportedException */ @Override protected ProductWithClone clone() throws CloneNotSupportedException { ProductWithClone product = (ProductWithClone) super.clone(); product.setName("acai copy"); return product; } }
2. Test
public class ProductWithCloneTest { public static void main(String[] args) throws CloneNotSupportedException { ProductWithClone product = new ProductWithClone("acai", 25, "earth"); //Clone an object ProductWithClone product1 = product.clone(); System.out.println(product); System.out.println(product1); } }
ProductWithClone{name='acai', age=25, address='earth'}
ProductWithClone{name='acai copy', age=25, address='earth'}
As can be seen from the results, another object was cloned.
Print out the object address to see:
com.example.pattern.prototype.ProductWithClone@1b6d3586
com.example.pattern.prototype.ProductWithClone@4554617c
product1 is cloned from the product object.
Template mode
What is the target mode
Define an algorithm skeleton, and implement some specific operations by subclasses, so that subclasses can change the specific implementation steps without changing the algorithm or process. The general process is unchanged and the implementation is changeable. For example, the example of operating a database.
This type of design pattern belongs to behavior pattern.
Example:
1. Define an abstract template class
Define a template class, and the operator() method implements the basic business logic, or public business logic.
templateMethod handles different situations.
public abstract class AbstractClass { void operator(){ System.out.println("connect open"); System.out.println("pre init"); templateMethod(); templateMethodV2(); System.out.println("connect close"); } /** * Implementation specific process */ abstract void templateMethod(); abstract void templateMethodV2(); }
2. Define a subclass to implement the template class
Define a subclass, inherit the template class, and re create the template class to provide methods that can handle specific business logic.
public class SubClass extends AbstractClass{ @Override void templateMethod() { System.out.println("insert into table"); } @Override void templateMethodV2() { System.out.println("update other tables"); } }
3. Test
public class TemplateTest { public static void main(String[] args) { AbstractClass aClass = new SubClass(); aClass.operator(); } }
connect open
pre init
insert into table
update other tables
connect close
Here, it is assumed that the operation of operating the database. First, connect the database. The preprocessing is completed in the template class. insert into table and update other tables are performed by child operations. connect close is completed in the template class.