乐趣区

关于java:从-crud-认识设计模式

jiezi

从 crud 意识设计模式

  • 在业务零碎中增删改查 (crud) 是常常须要开发的内容, 本文次要从增删改查来对设计模式进行一个学习或应用.
  • 个别咱们对一个表的增删改查有如下一些接口定义
boolean insert(Object o);
Object byId(Integer id);
boolean del(Integer id);
boolean editor(Integer interfaces, Object o;
  • 再带上 redis 的 crud 操作, 具体不进行列举.

整体操作

  • 在这里咱们仅针对单表而言

C- 创立

  • 通常咱们的创立流程是这样子的.

    1. 接管申请, 将申请转换为 db 对象, 长久化
    2. 如果须要制作缓存, 则放入缓存中
  • 伪代码如下
boolean b =  mapper.save(s)
if (b){redis.save(s)
}

R- 读取

  • 此处以 byId 为例. where 条件不易放入 redis 作为 key , 如果作为 key 数据量会过多

  • 通常操作

    1. 尝试从 redis 中读取
    2. 读取到了则返回, 没有读取到通过 db 进行查问
  • 伪代码
Object o =null
o = redis.read(id)
if (o ==null) {o = mapper.read(id)
}

U- 更新

  • 通常操作

    1. 删除 redis 的记录(防止读到假数据)
    2. 更新 db
    3. 放入 redis
  • 伪代码
redis.del()
mapper.update(o)
redis.save(o)

D- 删除

  • 通常操作

    1. redis 删除
    2. db 删除
  • 伪代码
redis.del()
mapper.del(o)

设计改进

  • 上述的操作大部分内容类似度很高, 在日常编写的时候咱们可能会常常写这样子的代码. 代码量过多, 以及代码复用率不是那么好. 因而对其做出改进.
  • 形象数据库操作和缓存操作. 其操作内容就是 CRUD 几个基本操作. 再次强调:单表操作

  • 在形象 crud 基本操作前须要在提出一个问题.

    • 咱们的主键可能是多种类型的. 常见有 int、varchar 这两种, 如何让咱们的 crud 接口更好的应用？
    • 上面是笔者提供的解决方案.

id 多类型的解决

  • 首先定义一个空接口 IdInterface 它用来标识这是一个 id 接口
public interface IdInterface {}

  • 依据罕用 int 和 varchar 设计出如下两个子接口. 他们的作用会在后续失去进一步的体现. 以后阶段仅须要晓得他们是 id 接口的继承即可.

    • 办法 id() 用来返回具体的 id 值
public interface IntIdInterface extends IdInterface {int id();
}

public interface StrIdInterface extends IdInterface {String id();
}

CRUD 根底接口形象

  • 首先定义 db 操作接口
public interface DbOperation<T, I extends IdInterface> {boolean insert(T t);

  T byId(I interfaces);

  boolean del(I interfaces);

  boolean editor(I interfaces, T t);

}
  • 代码解释, 此处应用泛型 T 来标识承受的类型, I 来标识接管的接口, 这里存在 2 中状况. 第一种 I = IntIdInterface , 第二种 I = StrIdInterface
  • 持续定义 redis 的操作
public interface RedisOperation<T, I extends IdInterface> {void insert(T t);

  void update(I i, T t);

  void del(I i);

  T byId(I i);

}
  • redis 缓存的数据结构抉择. 这里为了方便使用 id 进行查问抉择 hash 进行开发. 如有需要可自定义抉择数据结构.
  • redis 操作 hash 的行为也能够形象进去. 这里就不应用接口了. 应用一个父类来进行解决.
public abstract class RedisHashKeyOperation<T> {Gson gson = new Gson();
  @Autowired
  private StringRedisTemplate redisTemplate;

  protected void update(String key, String id, T t) {T redisObj = this.byId(key, id, t.getClass());
    if (!Objects.isNull(redisObj)) {

      // 如果是 redis 中的类型和以后传入的类型雷同
      if (redisObj.getClass().equals(t.getClass())) {this.insert(key, id, t);
      }
    }
  }

  protected void insert(String key, String id, T t) {redisTemplate.opsForHash().put(key, id, gson.toJson(t));
  }

  protected T byId(String key, String id, Class<?> clazz) {String o = (String) redisTemplate.opsForHash().get(key, id);
    return (T) gson.fromJson(o, clazz);
  }

  protected void delete(String key, String id) {this.redisTemplate.opsForHash().delete(key, id);
  }
}
  • 个别的对 redis hash 操作根本就是这样子的. 不会有过多的批改.
  • 创立两个表来应用以下. 实体对象 mapper 不在此进行开展代码
CREATE TABLE `project_int` (`id` int(32) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

CREATE TABLE `project_str` (`id` varchar(50) COLLATE utf8mb4_bin NOT NULL,
  `name` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;
  • 贴出一个 int 为主键的操作
@Service("ProjectIntDbOperationImpl")
public class ProjectIntDbOperationImpl implements DbOperation<ProjectInt, IntIdInterface> {

  @Autowired
  private ProjectIntMapper projectIntMapper;

  @Override
  public boolean insert(ProjectInt projectInt) {return projectIntMapper.insert(projectInt) > 0;
  }

  @Override
  public ProjectInt byId(IntIdInterface interfaces) {return projectIntMapper.selectByPrimaryKey(interfaces.id());
  }

  @Override
  public boolean del(IntIdInterface interfaces) {return projectIntMapper.deleteByPrimaryKey(interfaces.id()) > 0;
  }

  @Override
  public boolean editor(IntIdInterface interfaces, ProjectInt projectInt) {
    // 更新存在策略
    ProjectInt projectInt1 = this.byId(interfaces);
    projectInt1.setName(projectInt.getName());

    return this.projectIntMapper.updateByPrimaryKey(projectInt1) > 0;
  }

}



@Service("ProjectIntRedisOperationImpl")
public class ProjectIntRedisOperationImpl
    extends RedisHashKeyOperation<ProjectInt>
    implements
    RedisOperation<ProjectInt, IntIdInterface> {

  public static final String CACHE_PROJECT_INT = "cache:project_int";

  public void insert(ProjectInt projectInt) {super.insert(CACHE_PROJECT_INT, String.valueOf(projectInt.getId()), projectInt);
  }

  public void update(IntIdInterface strIdInterface, ProjectInt projectInt) {super.update(CACHE_PROJECT_INT, String.valueOf(strIdInterface.id()), projectInt);
  }

  public void del(IntIdInterface strIdInterface) {super.delete(CACHE_PROJECT_INT, String.valueOf(strIdInterface.id()));
  }

  public ProjectInt byId(IntIdInterface intIdInterface) {return super.byId(CACHE_PROJECT_INT, String.valueOf(intIdInterface.id()), ProjectInt.class);
  }

}
  • varchar 作为主键
@Service("ProjectStrDbOperationImpl")
public class ProjectStrDbOperationImpl implements DbOperation<ProjectStr, StrIdInterface> {

  @Autowired
  private ProjectStrMapper projectStrMapper;

  @Override
  public boolean insert(ProjectStr projectInt) {return projectStrMapper.insert(projectInt) > 0;
  }

  @Override
  public ProjectStr byId(StrIdInterface interfaces) {return projectStrMapper.selectByPrimaryKey(interfaces.id());
  }

  @Override
  public boolean del(StrIdInterface interfaces) {return projectStrMapper.deleteByPrimaryKey(interfaces.id()) > 0;
  }

  @Override
  public boolean editor(StrIdInterface interfaces, ProjectStr projectInt) {
    // 更新存在策略
    ProjectStr projectInt1 = this.byId(interfaces);
    projectInt1.setName(projectInt.getName());

    return this.projectStrMapper.updateByPrimaryKey(projectInt1) > 0;
  }
}


@Service("ProjectStrRedisOperationImpl")
public class ProjectStrRedisOperationImpl
    extends RedisHashKeyOperation<ProjectStr>
    implements
    RedisOperation<ProjectStr, StrIdInterface> {

  public static final String CACHE_PROJECT_INT = "cache:project_int";

  public void insert(ProjectStr projectStr) {super.insert(CACHE_PROJECT_INT, String.valueOf(projectStr.getId()), projectStr);
  }

  public void update(StrIdInterface strIdInterface, ProjectStr projectStr) {super.update(CACHE_PROJECT_INT, String.valueOf(strIdInterface.id()), projectStr);
  }

  public void del(StrIdInterface strIdInterface) {super.delete(CACHE_PROJECT_INT, String.valueOf(strIdInterface.id()));
  }

  public ProjectStr byId(StrIdInterface intIdInterface) {return super.byId(CACHE_PROJECT_INT, String.valueOf(intIdInterface.id()), ProjectStr.class);

  }

}
  • 基本操作曾经具备. 然而对外的办法还须要再一次进行形象. 在整体操作中,CRUD 的逻辑相似. 持续进行改良.
  • 对立对外提供的接口如下
public interface ByIdOperationFacade<T, I extends IdInterface> {boolean insert(T t);

  T byId(I i);

  boolean del(I i);

  boolean editor(I i, T t);

  DbOperation getDbOperation();}
  • 光有这个还不够. 咱们提供的对立 crud 办法还须要失去两个要害对象, 1. DbOperation 2. RedisOperation. 定义出操作汇合类
public class OperationCollections {

  private DbOperation dbOperation;

  private RedisOperation redisOperation;
}
  • 有了操作汇合. 短少一个生成它的工具
public interface ByIdOperationFactory {OperationCollections factory(Class<?> clazz);
  
}

  • 实现如下. 留神:此处为了让泛型更好的应用, 这里采纳的是类型对应一个操作对象(DbOperation,RedisOperation).

    • 须要改良的中央: 给DbOperation 和 RedisOperation 增加一个函数用来获取类型
@Service("ByIdOperationFactoryImpl")
public class ByIdOperationFactoryImpl implements ByIdOperationFactory {static Map<Class, DbOperation> dbOperationMap = new HashMap<>();
  static Map<Class, RedisOperation> redisOperationHashMap = new HashMap<>();
  @Autowired
  private ApplicationContext context;

  @PostConstruct
  public void init() {Map<String, DbOperation> beansOfType = context.getBeansOfType(DbOperation.class);
    beansOfType.forEach((k, v) -> {Class type = v.type();
          dbOperationMap.put(type, v);
        }
    );

    Map<String, RedisOperation> beansOfType1 = context.getBeansOfType(RedisOperation.class);
    beansOfType1.forEach((k, v) -> {Class type = v.type();
      redisOperationHashMap.put(type, v);
    });

  }

  @Override
  public OperationCollections factory(Class<?> clazz) {OperationCollections operationCollections = new OperationCollections();
    DbOperation dbOperation = dbOperationMap.get(clazz);
    RedisOperation redisOperation = redisOperationHashMap.get(clazz);

    operationCollections.setDbOperation(dbOperation);
    operationCollections.setRedisOperation(redisOperation);

    return operationCollections;
  }
}
  • 实现一个通用的 id 操作对象
public abstract class CommonByIdOperation<T, I extends IdInterface>
    implements ByIdOperationFacade<T, I> {

  @Autowired
  @Qualifier("ByIdOperationFactoryImpl")
  ByIdOperationFactory byIdOperationFactory;

  @Override
  public boolean insert(T t) {throw new RuntimeException("没有实现");
  }

  @Override
  public DbOperation getDbOperation() {throw new RuntimeException("没有实现");
  }

  public boolean editor(I i, T t) {

    boolean editor = false;

    OperationCollections operationCollections = this.operationCollection();
    RedisOperation redisOperation = operationCollections.getRedisOperation();

    if (redisOperation != null) {redisOperation.del(i);
    }

    DbOperation dbOperation = operationCollections.getDbOperation();

    if (dbOperation != null) {editor = dbOperation.editor(i, t);
    }

    if (redisOperation != null) {redisOperation.insert(t);
    }

    return editor;
  }


  public boolean del(I i) {
    boolean del = false;

    OperationCollections operationCollections = this.operationCollection();

    RedisOperation redisOperation = operationCollections.getRedisOperation();
    if (redisOperation != null) {redisOperation.del(i);
    }

    DbOperation dbOperation = operationCollections.getDbOperation();
    if (dbOperation != null) {del = dbOperation.del(i);
    }

    return del;
  }

  public T byId(I i) {
    T result = null;
    RedisOperation redisOperation = this.operationCollection().getRedisOperation();
    if (redisOperation != null) {result = (T) redisOperation.byId(i);
    }

    DbOperation dbOperation = this.operationCollection().getDbOperation();

    if (dbOperation != null) {if (result == null) {System.out.println("从数据库获取");
        result = (T) dbOperation.byId(i);
      }
    }

    return result;
  }


  public OperationCollections operationCollection() {return byIdOperationFactory.factory(clazz());
  }

  protected Class<?> clazz() {throw new IllegalArgumentException("类型异样");
  }
}
  • 阐明: 这里的 insert 操作不倡议在此进行解决. 应为 id 是在 mybatis 插入后才会有. 当然也能够通过一个 bean—copy 的形式在这里获取. 然而咱们的命名如果不同. beanCopy 就不行了.
  • 简略概述 bean-copy 的形式
public class BeanCopy {public static void main(String[] args) {StrId strId = new StrId();
    strId.setId("str_id");

    CpId cpId = new CpId();
    BeanUtils.copyProperties(strId, cpId);
    System.out.println(cpId.getId());
  }
  @Data
  static class CpId {private Object id;}

  @Data
  static class StrId {private String id;}
}
  • 最初的组装过程
@Service("ProjectIntDbOperationImpl")
public class ProjectIntDbOperationImpl implements DbOperation<ProjectInt, IntIdInterface> {

  @Autowired
  private ProjectIntMapper projectIntMapper;

  @Override
  public boolean insert(ProjectInt projectInt) {return projectIntMapper.insert(projectInt) > 0;
  }

  @Override
  public ProjectInt byId(IntIdInterface interfaces) {return projectIntMapper.selectByPrimaryKey(interfaces.id());
  }

  @Override
  public boolean del(IntIdInterface interfaces) {return projectIntMapper.deleteByPrimaryKey(interfaces.id()) > 0;
  }

  @Override
  public boolean editor(IntIdInterface interfaces, ProjectInt projectInt) {
    // 更新存在策略
    ProjectInt projectInt1 = this.byId(interfaces);
    projectInt1.setName(projectInt.getName());

    return this.projectIntMapper.updateByPrimaryKey(projectInt1) > 0;
  }

  @Override
  public Class<?> type() {return ProjectInt.class;}
}
@Service("ProjectStrFacade")
public class ProjectStrFacade extends CommonByIdOperation<ProjectStr, StrIdInterface> implements
    ByIdOperationFacade<ProjectStr, StrIdInterface> {

  @Override
  public boolean insert(ProjectStr projectInt) {DbOperation dbOperation = this.getDbOperation();
    boolean insert = false;
    if (dbOperation != null) {insert = dbOperation.insert(projectInt);
    }
    RedisOperation redisOperation = this.operationCollection().getRedisOperation();
    if (redisOperation != null) {redisOperation.insert(projectInt);
    }
    return insert;
  }

  @Override
  public ProjectStr byId(StrIdInterface strIdInterface) {return super.byId(strIdInterface);
  }

  @Override
  public boolean del(StrIdInterface strIdInterface) {return super.del(strIdInterface);
  }

  public boolean editor(StrIdInterface strIdInterface, ProjectStr projectInt) {return super.editor(strIdInterface, projectInt);
  }

  @Override
  public DbOperation getDbOperation() {return this.operationCollection().getDbOperation();}

  @Override
  protected Class<?> clazz() {return ProjectStr.class;}
}

测试

@SpringBootTest
class DemoApplicationTests {Gson gson = new Gson();
  @Autowired
  private ProjectStrMapper projectStrMapper;
  @Autowired
  @Qualifier("projectIntFacade")
  private ByIdOperationFacade<ProjectInt, IntIdInterface> byIdOperationFacade;
  @Autowired
  private StringRedisTemplate stringRedisTemplate;

  @Test
  void testInsert() {ProjectInt projectInt = new ProjectInt();
    projectInt.setName("JJJ");
    this.byIdOperationFacade.insert(projectInt);
  }

  @Test
  void testUpdate() {ProjectInt projectInt = this.byIdOperationFacade.byId(new IntIdInterface() {
      @Override
      public int id() {return 1;}
    });

    projectInt.setName("update");
    this.byIdOperationFacade.editor(new IntIdInterface() {
      @Override
      public int id() {return projectInt.getId();
      }
    }, projectInt);
  }

  @Test
  void testDel() {this.byIdOperationFacade.del(new IntIdInterface() {
      @Override
      public int id() {return 1;}
    });
  }

  @Test
  void testById() {ProjectInt projectInt = this.byIdOperationFacade.byId(new IntIdInterface() {
      @Override
      public int id() {return 1;}
    });
    System.out.println();}
}
  • 咱们对外裸露的类只有 ByIdOperationFacade.
  @Autowired
  @Qualifier("projectIntFacade")
  private ByIdOperationFacade<ProjectInt, IntIdInterface> byIdOperationFacade;
  • 通过不同的实现来操作不同的数据库对象

总结

  • 本文应用了

    1. 模板模式
    2. 工厂模式
    3. 门面模式
  • 仓库地址: https://github.com/huifer/crud
退出移动版