设计模式的使用——建造者模式+适配器模式
项目代码地址
一、需求介绍
现公司数据库有一张表中的数据，需要通过外部接口将数据推送到别人的系统中。现有的问题是：
- 数据字段太多，而且双方系统实体字段不一致，每次都要通过get、set方法去对数据取值然后重新赋值。
- 如果后期需要添加数据或者减少数据，修改不方便。
二、设计模式选择
- 建造者模式（Builder）：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。
- 适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。我们这里选择对象
我们可以通过建造者模式去解决字段多且赋值困难问题，使用适配器模式去将我们系统的值转换为请求接口需要的值。
三、代码实现
1、准备实体类
- 本地需要被转换的对象LocalEmployee.java，即适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
package com.company.modeTest.dto;
public class LocalEmployee {
private Integer id = 1;
private String name = "我类个乖乖";
private Integer age = 18;
private Integer sex = 1;
private String address;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", age='" + age + '\'' +
", sex=" + sex +
", address=" + address +
'}';
}
}
- 远程接口需要的对象：RemoteEmployee.java、RemotePosition.java、RemoteRole.java。
package com.company.modeTest.dto;
import java.util.List;
public class RemoteEmployee {
private Integer remoteId;
private String remoteName;
private Integer remoteAge;
private Integer remoteSex;
private String remoteAddress;
private List<RemoteRole> roles;
private RemotePosition position;
public List<RemoteRole> getRoles() {
return roles;
}
public void setRoles(List<RemoteRole> roles) {
this.roles = roles;
}
public RemotePosition getPosition() {
return position;
}
public void setPosition(RemotePosition position) {
this.position = position;
}
public Integer getRemoteId() {
return remoteId;
}
public void setRemoteId(Integer remoteId) {
this.remoteId = remoteId;
}
public String getRemoteName() {
return remoteName;
}
public void setRemoteName(String remoteName) {
this.remoteName = remoteName;
}
public Integer getRemoteAge() {
return remoteAge;
}
public void setRemoteAge(Integer remoteAge) {
this.remoteAge = remoteAge;
}
public Integer getRemoteSex() {
return remoteSex;
}
public void setRemoteSex(Integer remoteSex) {
this.remoteSex = remoteSex;
}
public String getRemoteAddress() {
return remoteAddress;
}
public void setRemoteAddress(String remoteAddress) {
this.remoteAddress = remoteAddress;
}
@Override
public String toString() {
return "RemoteEmployee{" +
"remoteId=" + remoteId +
", remoteName='" + remoteName + '\'' +
", remoteAge='" + remoteAge + '\'' +
", remoteSex=" + remoteSex +
", remoteAddress='" + remoteAddress + '\'' +
", roles=" + roles +
", position=" + position +
'}';
}
}
package com.company.modeTest.dto;
public class RemotePosition {
private Integer positionId;
private String positionName;
public Integer getPositionId() {
return positionId;
}
public void setPositionId(Integer positionId) {
this.positionId = positionId;
}
public String getPositionName() {
return positionName;
}
public void setPositionName(String positionName) {
this.positionName = positionName;
}
@Override
public String toString() {
return "RemotePosition{" +
"positionId=" + positionId +
", positionName='" + positionName + '\'' +
'}';
}
}
package com.company.modeTest.dto;
public class RemoteRole {
private Integer roleId;
private String roleName;
public Integer getRoleId() {
return roleId;
}
public void setRoleId(Integer roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
@Override
public String toString() {
return "RemoteRole{" +
"roleId=" + roleId +
", roleName='" + roleName + '\'' +
'}';
}
}
2、编写建造者模式代码
- 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法。
package com.company.modeTest.builder;
/**
* 抽象建造者
* @param 要构建的对象
*/
public interface BaseBuilder<O> {
O build();
}
- 对抽象建造者增强
package com.company.modeTest.builder;
/**
* 对抽象建造者进行功能增强，使其支持..and()...的链式编码风格
* @param 要构建的对象
* @param 被构建对象的具体建造者
*/
public abstract class AbstractParamBuilderAdapter<O,B extends BaseBuilder<O>> {
private B builder;
void setBuilder(B builder) {
this.builder = builder;
}
protected final B getBuilder() {
return builder;
}
public B and() {
return getBuilder();
}
}
- 具体建造者
package com.company.modeTest.builder;
import com.company.modeTest.dto.RemoteEmployee;
import com.company.modeTest.dto.RemotePosition;
public class PositionBuilder extends AbstractParamBuilderAdapter<RemoteEmployee,EmployeeBuilder> implements BaseBuilder<RemotePosition>{
private final RemotePosition remotePosition = new RemotePosition();
public PositionBuilder positionId(Integer positionId){
remotePosition.setPositionId(positionId);
return this;
}
public PositionBuilder positionName(String positionName){
remotePosition.setPositionName(positionName);
return this;
}
@Override
public RemotePosition build() {
return remotePosition;
}
}
package com.company.modeTest.builder;
import com.company.modeTest.dto.RemoteEmployee;
import com.company.modeTest.dto.RemoteRole;
public class RoleBuilder extends AbstractParamBuilderAdapter<RemoteEmployee,EmployeeBuilder> implements BaseBuilder<RemoteRole>{
private final RemoteRole remoteRole = new RemoteRole();
public RoleBuilder roleId(Integer roleId){
remoteRole.setRoleId(roleId);
return this;
}
public RoleBuilder roleName(String roleName){
remoteRole.setRoleName(roleName);
return this;
}
@Override
public RemoteRole build() {
return remoteRole;
}
}
package com.company.modeTest.builder;
import com.company.modeTest.dto.RemoteEmployee;
import com.company.modeTest.dto.RemoteRole;
import java.util.ArrayList;
import java.util.List;
public class EmployeeBuilder implements BaseBuilder<RemoteEmployee>{
private final RemoteEmployee remoteEmployee = new RemoteEmployee();
private final List<RoleBuilder> roleBuilders = new ArrayList<>();
private final List<RemoteRole> roles = new ArrayList<>();
private PositionBuilder positionBuilder;
public EmployeeBuilder remoteId(Integer remoteId){
remoteEmployee.setRemoteId(remoteId);
return this;
}
public EmployeeBuilder remoteName(String remoteName){
remoteEmployee.setRemoteName(remoteName);
return this;
}
public EmployeeBuilder remoteAge(Integer remoteAge){
remoteEmployee.setRemoteAge(remoteAge);
return this;
}
public EmployeeBuilder remoteSex(Integer remoteSex){
remoteEmployee.setRemoteSex(remoteSex);
return this;
}
public EmployeeBuilder remoteAddress(String remoteAddress){
remoteEmployee.setRemoteAddress(remoteAddress);
return this;
}
public RoleBuilder roles(){
RoleBuilder roleBuilder = new RoleBuilder();
roleBuilder.setBuilder(this);
roleBuilders.add(roleBuilder);
return roleBuilder;
}
public PositionBuilder position(){
if (positionBuilder==null){
positionBuilder = new PositionBuilder();
}
positionBuilder.setBuilder(this);
return positionBuilder;
}
@Override
public RemoteEmployee build() {
if (positionBuilder!=null){
remoteEmployee.setPosition(positionBuilder.build());
}
if (roleBuilders.size()>0){
for (RoleBuilder roleBuilder : roleBuilders) {
roles.add(roleBuilder.build());
}
remoteEmployee.setRoles(roles);
}
return remoteEmployee;
}
}
3、编写适配器模式代码
- 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
package com.company.modeTest.adapter;
/**
* 目标（Target）接口
* @param 所要适配的数据源
* @param 所要适配的对象，即需要的结果
*/
public interface Target<F,T> {
T adaptData(F fromData);
}
- 对把目标接口进行增强，暴露建造者，使用户可以自定义构建数据，无需了解底层代码
package com.company.modeTest.adapter;
import com.company.modeTest.builder.BaseBuilder;
/**
* @param 被构架你对象的建造者
* @param 被构建的对象
* @param 所要适配的数据源
*/
public abstract class AbstractDataTarget<D extends BaseBuilder<O>,O,F> implements Target<F,O> ,BaseBuilder<O>{
public D dataBuilder;
public D addInfo(){
return dataBuilder;
}
@Override
public O build() {
return dataBuilder.build();
}
}
- 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。在这里，我们调用建造者，对接口必须的数据数据进行转换，并返回接口所需数据对象。
package com.company.modeTest.adapter;
import com.company.modeTest.builder.EmployeeBuilder;
import com.company.modeTest.dto.LocalEmployee;
import com.company.modeTest.dto.RemoteEmployee;
public class EmployeeAdapter extends AbstractDataTarget<EmployeeBuilder, RemoteEmployee, LocalEmployee>{
public EmployeeAdapter() {
dataBuilder = new EmployeeBuilder();
}
@Override
public RemoteEmployee adaptData(LocalEmployee fromData) {
return dataBuilder
.remoteId(fromData.getId())
.remoteName(fromData.getName())
.remoteAge(fromData.getAge())
.remoteSex(fromData.getSex())
.build();
}
}
4、代码测试
package com.company.modeTest;
import com.company.modeTest.adapter.EmployeeAdapter;
import com.company.modeTest.dto.LocalEmployee;
import com.company.modeTest.dto.RemoteEmployee;
import org.junit.Test;
public class MainTest {
@Test
public void test(){
LocalEmployee localEmployee = new LocalEmployee();
System.out.println("本地原始数据localEmployee---->"+localEmployee);
EmployeeAdapter employeeAdapter = new EmployeeAdapter();
RemoteEmployee remoteEmployee = employeeAdapter.adaptData(localEmployee);
System.out.println("适配获取的远程接口需要的数据remoteEmployee---->"+remoteEmployee);
System.out.println("=====================用户开始自定义添加额外信息========");
employeeAdapter.addInfo()
.remoteAddress("中国加拿大省美市英县日本村")
.position()
.positionId(2)
.positionName("技师")
.and()
.roles()
.roleId(3)
.roleName("太太")
.and()
.build();
System.out.println("用户添加额外信息后remoteEmployee--->"+remoteEmployee);
}
}
测试结果：
