Back to home

Become More Productive Software Developer Using with Copilot Chat

01/02/2024

Become More Productive Software Developer Using with Copilot Chat

This article is also available on Medium

I think Senior software developers will have a new responsibility. This is to create code templates. Because our projects have so many duplicate code. If you use Spring Boot framework or Express.js, you must write duplicate code for entity, repository or crud operations.

There are so many tricks for making easy crud projects for example Jhipster project. But this solutions not enough flexible. But brand new Copilot Chat or LLM supported Coding AI tools flexible and adaptable for your specific solutions. For example if your projects have repeatable coding requirements like an endpoint for simple update single field of single entity. You can create a templete for this repeatable solution. I think this solution not available until OpenAI released to ChatGPT 3.5.

Let’s continue with real world examples.

This is a MD file “admin-page-guideline.md”:

########################### STARTED ###########################

This is a copilot guideline for easy create new admin page. Admin page in generally crud page. But we have our code style and libraries for create admin page.

This project just create admin page backend site with java spring boot.

When we create admin page on backend, collect this data for determine required scope.

  1. Which entity will be used for this page.
  2. Which CRUD operations will be used for this page. (LIST, CREATE, UPDATE, DELETE)

When we create admin page on backend, we have to create 4 part.

  1. JpaExtendRepository for existing entity and repository.
  2. Create new DTO for Page Response.
  3. Service for business logic.
  4. Controller for rest api.

Example: We have a entity name is FlyRecord. We have to create 4 part for User entity.

JpaExtendRepository

package com.beyt.app.repository;
import com.beyt.repository.JpaExtendedRepository;
import com.beyt.app.common.entity.search.FlyRecord;
import com.beyt.app.common.repository.search.FlyRecordRepository;
import org.springframework.stereotype.Repository;
@Repository
// NEED FOR: CREATE, UPDATE, DELETE this part will be use
public interface FlyRecordExtendedRepository extends FlyRecordRepository, JpaExtendedRepository<FlyRecord, Long> {
}

DTO

package com.hipi.beyt.app.admin;
import com.beyt.app.common.entity.search.FlyRecord;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.Date;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class FlyRecordDTO implements Serializable {
 private Long flyRecordId;
@NotNull
 private FlyRecord.Type type;
@NotBlank
 private String keyword;
@NotBlank
 private String bindTerm;
// NEED FOR: LIST, CREATE, UPDATE 
 public FlyRecordDTO(FlyRecord rule) {
 this.flyRecordId = rule.getId();
 this.type = rule.getType();
 this.keyword = rule.getKeyword();
 this.bindTerm = rule.getBindTerm();
 }
// NEED FOR: CREATE AND UPDATE 
 public FlyRecord toEntity() {
 FlyRecord entity = new FlyRecord();
 updateEntity(entity);
 
 return entity;
 }
// NEED FOR: CREATE AND UPDATE
 public FlyRecord updateEntity(FlyRecord entity) {
 entity.setType(this.getType());
 entity.setKeyword(this.getKeyword());
 entity.setBindTerm(this.getBindTerm());
return entity;
 }
}

Service

package com.beyt.app.service.admin;
import com.beyt.dto.SearchQuery;
import com.beyt.app.common.entity.search.FlyRecord;
import com.beyt.app.dto.admin.FlyRecordDTO;
import com.beyt.app.repository.FlyRecordExtendedRepository;
import com.beyt.app.service.base.BaseManagementService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.validation.Valid;
import java.util.Objects;
import java.util.Optional;
@Slf4j
@Service
@RequiredArgsConstructor
public class FlyRecordManagementService extends BaseManagementService {
 private final FlyRecordExtendedRepository flyRecordExtendedRepository;
// NEED FOR: LIST
 @Transactional(readOnly = true)
 public Page<FlyRecordDTO> listEntityByFilter(SearchQuery searchQuery) {
 checkSearchQuery(searchQuery);
 Page<FlyRecord> page = flyRecordeExtendedRepository.findAllWithSearchQueryAsPage(searchQuery);
 return new PageImpl<>(page.stream().map(FlyRecordDTO::new).toList(), page.getPageable(), page.getTotalElements());
 }
// NEED FOR: CREATE, UPDATE 
 @Transactional
 public FlyRecordDTO updateEntity(@Valid FlyRecordDTO dto) {
 Optional<FlyRecord> entityOpt;
if (Objects.nonNull(dto.getFlyRecordId())) {
 entityOpt = flyRecordExtendedRepository.findById(dto.getFlyRecordId());
 } else {
 entityOpt = Optional.empty();
 }
FlyRecord entity = entityOpt.map(dto::updateEntity).orElse(dto.toEntity());
 flyRecordExtendedRepository.save(entity);
 return dto;
 }
// NEED FOR: DELETE
 @Transactional
 public void deleteEntity(Long id) {
 flyRecordExtendedRepository.deleteById(id);
 }
}

Controller

package com.beyt.app.controller.admin;
import com.beyt.dto.SearchQuery;
import org.springframework.http.ResponseEntity;
import com.beyt.app.annotation.Authorized;
import com.beyt.app.controller.base.BaseManagementController;
import com.beyt.app.dto.admin.FlyRecordDTO;
import com.beyt.app.enumeration.AuthType;
import com.beyt.app.service.admin.FlyRecordManagementService;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import javax.validation.constraints.Min;
@Tag(description = "/admin/smart-search-rule", name = "Admin Smart Search Rule Management API")
@RestController
@RequestMapping("/admin/smart-search-rule")
@RequiredArgsConstructor
public class FlyRecordManagementController extends BaseManagementController {
 private final FlyRecordManagementService flyRecordManagementService;
// NEED FOR: LIST
 @Authorized(authTypes = AuthType.ADMIN)
 @GetMapping({"", "/"})
 public ResponseEntity<Page<FlyRecordDTO>> listEntityByFilter(SearchQuery searchQuery) {
 return ok(flyRecordManagementService.listEntityByFilter(searchQuery));
 }
// NEED FOR: CREATE, UPDATE 
 @Authorized(authTypes = AuthType.ADMIN)
 @PostMapping({"", "/"})
 public ResponseEntity<FlyRecordDTO> updateEntity(@RequestBody @Valid FlyRecordDTO dto) {
 return ok(flyRecordManagementService.updateEntity(dto));
 }
// NEED FOR: DELETE
 @Authorized(authTypes = AuthType.ADMIN)
 @DeleteMapping("/{id}")
 public ResponseEntity<String> deleteEntity(@PathVariable @Min(1) Long id) {
 flyRecordManagementService.deleteEntity(id);
 return ok("OK");
 }
}

########################### FINISED ############################

How to use:

Intellij Copilot have a great feature for using this method. You can add related all documents. So we need to add related guideline and related classes. Copilot generate all classes at the same response. Just create one guideline and use easily.

If you want to learn what is magical JpaExtendedRepository check githup repo for learn every thing: https://github.com/tdilber/spring-jpa-generic-criteria

What Else I Use This Guidelines

I used this guidelines for create entity. Because our company projects have so many restrictions and rules for create entity. For example what is base class, how to use foreign keys, if string=> notBlank, if object=> notNull bla bla. And also create 2 file 1 of entity class the other migration file.

I created the other guideline for create admin ui. You can imagine moreover this examples.

Conclusion

This code generation technique is not end of software development. Because engineers must know every detail of generation. Your coding skills much more better than this generation. But If you need more than 5–10 times replication of the same coding style. Then You should create a guideline for generating easily and faster. Nowadays AI help us for coding and researching. We must try to adapt this AI because It maybe be better then us, in this future.