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

4次阅读

共计 12073 个字符，预计需要花费 31 分钟才能阅读完成。

在业务零碎中增删改查 (crud) 是常常须要开发的内容, 本文次要从增删改查来对设计模式进行一个学习或应用.
个别咱们对一个表的增删改查有如下一些接口定义

boolean insert(Object o);
Object byId(Integer id);
boolean del(Integer id);
boolean editor(Integer interfaces, Object o;

再带上 redis 的 crud 操作, 具体不进行列举.

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

通常咱们的创立流程是这样子的.
1. 接管申请, 将申请转换为 db 对象, 长久化
2. 如果须要制作缓存, 则放入缓存中
伪代码如下

boolean b =  mapper.save(s)
if (b){redis.save(s)
}

此处以 byId 为例. where 条件不易放入 redis 作为 key , 如果作为 key 数据量会过多
通常操作
1. 尝试从 redis 中读取
2. 读取到了则返回, 没有读取到通过 db 进行查问
伪代码

Object o =null
o = redis.read(id)
if (o ==null) {o = mapper.read(id)
}

通常操作
1. 删除 redis 的记录(防止读到假数据)
2. 更新 db
3. 放入 redis
伪代码

redis.del()
mapper.update(o)
redis.save(o)

通常操作
1. redis 删除
2. db 删除
伪代码

redis.del()
mapper.del(o)

上述的操作大部分内容类似度很高, 在日常编写的时候咱们可能会常常写这样子的代码. 代码量过多, 以及代码复用率不是那么好. 因而对其做出改进.
形象数据库操作和缓存操作. 其操作内容就是 CRUD 几个基本操作. 再次强调:单表操作
在形象 crud 基本操作前须要在提出一个问题.
- 咱们的主键可能是多种类型的. 常见有 int、varchar 这两种, 如何让咱们的 crud 接口更好的应用？
- 上面是笔者提供的解决方案.

首先定义一个空接口 IdInterface 它用来标识这是一个 id 接口

public interface IdInterface {}

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

public interface IntIdInterface extends IdInterface {int id();
}

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

首先定义 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

正文完

java

发表至： java

2020-08-11

0

关于java:分享一个网上搜不到的Redis实现聊天回合制的方案

设计模式之观察者模式

关于java:Java学习笔记Day03

SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）

关于java:给Swagger换了个新皮肤瞬间高大上了

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

从 crud 意识设计模式

整体操作

C- 创立

R- 读取

U- 更新

D- 删除

设计改进

id 多类型的解决

CRUD 根底接口形象

测试

总结

站内搜索