用仿制药简化CRUD操作：抽象CRUD服务-DEV365 开发者社区

让我们探索智能使用仿制药如何帮助我们避免编写重复的样板代码。我们将通过创建抽象的CRUD（创建，阅读，更新，删除）服务来证明这一点，该服务使开发人员可以提高其生产率并更多地专注于基本业务逻辑。让我们开始！

步骤1：了解问题
开发软件时，通常会遇到重复代码模式，尤其是在实施CRUD操作时。这些操作通常涉及可以推广的类似结构和功能。为了解决这个问题，我们可以利用仿制药的力量创建一个抽象的CRUD服务，以消除对冗余代码的需求。

这有助于我们编写简化的服务类，以专注于业务逻辑。如下所示。


@Service
@RequiredArgsConstructor
public class MyService extends AbstractCrudService<Employee, EmployeeEntity, Integer>{
    private final EmployeeRepository employeeRepository;
    @Override
    protected JpaRepository<EmployeeEntity, Integer> getJpaRepository() {
        return employeeRepository;
    }

    @Override
    protected Optional<EmployeeEntity> findUnique(Employee model) {
        return employeeRepository.findByRegistrationNumber(model.getRegistrationNumber());
    }

    @Override
    public Employee preCreate(Employee model) {
        // Generate and assign registration number here
        model.setRegistrationNumber(generate(16));
        return model;
    }
}

如何实现这一目标？

让我们定义具有以下属性和初始化的抽象类。这是确定运行时模型和实体类所必需的。

@Service
public abstract class AbstractCrudService<Model, Entity, ID> implements CrudService<Model, Entity, ID>, 
        CrudExtnService<Model, Entity, ID>{

    @Autowired
    private ModelMapper modelMapper;
    private Class<Model> modelClass;
    private Class<Entity> entityClass;

    @SuppressWarnings({ "unchecked", "rawtypes" })
    public AbstractCrudService() {
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        Type[] typeArgs = type.getActualTypeArguments();

        this.modelClass = ((Class) typeArgs[0]);
        this.entityClass = ((Class) typeArgs[1]);
    }

现在让我们定义一些必须由服务实现的抽象方法。这是必需的

    protected abstract JpaRepository<Entity, ID> getJpaRepository();

    protected abstract Optional<Entity> findUnique(Model model);

以下通用方法将提供所有CRUD操作。

    @Override
    public List<Model> findAll() {
        return getJpaRepository().findAll().stream().map(e -> onList(toDto(e), e)).toList();
    }

    @Override
    public Optional<Model> getById(ID id) {
        return toDto(getJpaRepository().findById(id));
    }

    @Override
    public Model save(Model model) {
        Optional<Entity> dbInstance = findUnique(model);
        if (dbInstance.isPresent()) {
            return update(model, dbInstance.get());
        } else {
            return create(model);
        }
    }

    @Override
    public void delete(ID id) {
        getJpaRepository().deleteById(id);
    }

    private Optional<Model> toDto(Optional<Entity> entity) {
        if (entity.isPresent()) {
            Entity e = entity.get();
            return Optional.of(onGet(modelMapper.map(e, getModelClass()), e));
        } else
            return Optional.empty();
    }

    private Model toDto(Entity entity) {
        return modelMapper.map(entity, getModelClass());
    }

    private Model create(Model model) {
        model = preCreate(model);
        Entity entity = modelMapper.map(model, getEntityClass());
        getJpaRepository().save(entity);
        return postCreate(toDto(entity), entity);
    }

    private Model update(Model model, Entity entity) {
        model = preUpdate(model);
        modelMapper.map(model, entity);
        getJpaRepository().save(entity);
        return postUpdate(toDto(entity), entity);
    }

您可以使用prepdate，预处理方法等的默认方法（作为钩子）定义接口，并使用此方法在保存之前执行自定义操作，查询数据等，

遵循本教程，您已经学会了如何利用仿制药创建抽象的CRUD服务。这种方法使您可以消除重复的样板代码，并更多地专注于实现应用程序的核心业务逻辑。结果，您的开发过程变得更加有效和可维护。在未来的项目中尝试仿制药，并释放提高生产率的潜力！