下面列出了org.hibernate.exception.ConstraintViolationException#org.springframework.dao.DuplicateKeyException 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public ServiceApiVersion add(AddServiceApiVersionRequestBody body) {
String apiVersion = body.getApiVersion();
String serviceId = body.getServiceId();
String desc = body.getDesc();
String userId = this.getUserId();
//新增
Date now = new Date();
ServiceApiVersion serviceApiVersion = new ServiceApiVersion();
serviceApiVersion.setId(SnowflakeIdWorker.getId());
serviceApiVersion.setApiVersion(apiVersion);
serviceApiVersion.setServiceId(serviceId);
serviceApiVersion.setUserId(userId);
serviceApiVersion.setDescription(desc);
serviceApiVersion.setCreateTime(now);
serviceApiVersion.setUpdateTime(now);
try {
this.serviceApiVersionMapper.insert(serviceApiVersion);
return serviceApiVersion;
} catch (DuplicateKeyException ex) {
logger.warn("service version duplicate key " + ex.getMessage());
return this.find(apiVersion, serviceId);
}
}
@Override
public ProjectMember addCreator(String projectId) {
String userId = this.getUserId();
ProjectMember projectMember = new ProjectMember();
projectMember.setId(SnowflakeIdWorker.getId());
projectMember.setUserId(userId);
projectMember.setCreator((byte) DBEnumInt.CREATOR_Y.getIndex());
projectMember.setProjectId(projectId);
projectMember.setCreateTime(new Date());
try {
this.projectMemberMapper.insert(projectMember);
return projectMember;
} catch (DuplicateKeyException ex) {
logger.warn("project member duplicate key " + ex.getMessage());
return this.find(userId, projectId);
}
}
@Override
public ProjectMember add(String userId, String projectId) {
ProjectMember projectMember = new ProjectMember();
projectMember.setId(SnowflakeIdWorker.getId());
projectMember.setUserId(userId);
projectMember.setCreator((byte) DBEnumInt.CREATOR_N.getIndex());
projectMember.setProjectId(projectId);
projectMember.setCreateTime(new Date());
try {
this.projectMemberMapper.insert(projectMember);
return projectMember;
} catch (DuplicateKeyException ex) {
logger.warn("project member duplicate key " + ex.getMessage());
return this.find(userId, projectId);
}
}
@Override
public com.iflytek.ccr.polaris.cynosure.domain.Service add(AddServiceRequestBody body) {
String name = body.getName();
String desc = body.getDesc();
String userId = this.getUserId();
String clusterId = body.getClusterId();
//新增
Date now = new Date();
com.iflytek.ccr.polaris.cynosure.domain.Service service = new com.iflytek.ccr.polaris.cynosure.domain.Service();
service.setId(SnowflakeIdWorker.getId());
service.setName(name);
service.setDescription(desc);
service.setUserId(userId);
service.setGroupId(clusterId);
service.setCreateTime(now);
try {
this.serviceMapper.insert(service);
return service;
} catch (DuplicateKeyException ex) {
logger.warn("service duplicate key " + ex.getMessage());
return this.find(name, clusterId);
}
}
@Transactional
@CacheEvict(value = "collections", key = "#collectionId")
public Boolean addIllustrationToCollection(Integer userId, Integer collectionId, Illustration illustration) {
//校验collectionId是否属于用户
checkCollectionAuth(collectionId, userId);
Collection collection = queryCollectionByIdFromDb(collectionId);
//插入
try {
collectionMapper.incrCollectionIllustCount(collectionId);
collectionMapper.addIllustrationToCollection(collectionId, illustration.getId());
if (collection.getIllustCount() == 0) {
collectionMapper.updateCollectionCover(collectionId, illustrationBizService.queryIllustrationById(illustration.getId()));
}
} catch (DuplicateKeyException e) {
throw new BusinessException(HttpStatus.BAD_REQUEST, "画作在该画集中已经存在");
}
return true;
}
private void createSuccessTopic(TopicEntity topicEntity) {
TopicEntity entity= topicService.getTopicByName(topicEntity.getName());
if(entity!=null){
throw new CheckFailException("topic:"+topicEntity.getName()+"重复，检查是否有重名topic已经存在。");
}
try {
topicService.insert(topicEntity);
} catch (DuplicateKeyException e) {
throw new CheckFailException("topic:" + topicEntity.getName() + "重复，检查是否有重名topic已经存在。");
}
uiAuditLogService.recordAudit(TopicEntity.TABLE_NAME, topicEntity.getId(),
"新建topic，" + JsonUtil.toJson(topicEntity));
// 计算分配的队列数
int expectDayCount = topicEntity.getExpectDayCount() * 10000;
int successQueueNum = expectDayCount / Constants.MSG_NUMS_OF_ONE_QUEUE;
// 分配队列
topicService.distributeQueueWithLock(topicEntity, successQueueNum,
NodeTypeEnum.SUCCESS_NODE_TYPE.getTypeCode());
}
@Override
public void add(ExecutorPlugin executorPlugin) {
Preconditions.checkArgument(executorPlugin != null, "executorPlugin不能为空");
Preconditions.checkArgument(StringUtils.isNotBlank(executorPlugin.getName()), "name不能为空");
Preconditions.checkArgument(executorPlugin.getContainerId() != null, "containerId不能为空");
ExecutorPlugin existModel = executorPluginMapper.getByName(executorPlugin.getName());
if (existModel != null) {
throw new ExecutorRuntimeException("该名称已经存在");
}
if (executorContainerService.getById(executorPlugin.getContainerId()) == null) {
throw new ExecutorRuntimeException("该容器不存在");
}
executorPlugin.setStatus(StatusType.ON.getValue());
try {
executorPluginMapper.insert(executorPlugin);
} catch (DuplicateKeyException e) {
LOG.error("add executor container duplicate, name:{}", executorPlugin.getName());
throw new ExecutorRuntimeException("该插件名称已经存在");
}
}
@Override
public void add(ExecutorContainer container) throws ExecutorRuntimeException{
Preconditions.checkArgument(container != null, "model不能为空");
Preconditions.checkArgument(StringUtils.isNotBlank(container.getName()), "name不能为空");
ExecutorContainer existContainer = executorContainerMapper.getByName(container.getName());
if (existContainer != null) {
throw new ExecutorRuntimeException("该容器名称已经存在");
}
container.setStatus(StatusType.ON.getValue());
try {
executorContainerMapper.insert(container);
} catch (DuplicateKeyException e) {
LOG.error("add executor container duplicate, name:{}", container.getName());
throw new ExecutorRuntimeException("已经存在同名的执行容器");
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void addConnection(Connection<?> connection) {
try {
ConnectionData data = connection.createData();
UserConnection userConnection = new UserConnection();
userConnection.setProviderUserName(data.getDisplayName());
userConnection.setImageUrl(data.getImageUrl());
userConnection.setAccessToken(encrypt(data.getAccessToken()));
userConnection.setSecret(encrypt(data.getSecret()));
userConnection.setRefreshToken(encrypt(data.getRefreshToken()));
userConnection.setProviderId(data.getProviderId());
userConnection.setProviderUserId(data.getProviderUserId());
userConnection.setExpireTime(data.getExpireTime());
userConnection.setUserId(userId);
this.userConnectionRepository.save(userConnection);
} catch (DuplicateKeyException e) {
throw new DuplicateConnectionException(connection.getKey());
}
}
@Override
public void create(SpaceBO spaceBO) {
SpaceDO spaceDO = convertToDO(spaceBO);
Date now = new Date();
spaceDO.setId(null);
spaceDO.setGmtCreate(now);
spaceDO.setGmtModified(now);
int resultSize;
try {
resultSize = spaceDOMapper.insert(spaceDO);
} catch (DuplicateKeyException e) {
throw new BizException(ResultCode.DUPLICATE_KEY_SPACE);
}
if (resultSize != 1) {
throw new IncorrectResultSizeException(resultSize);
}
}
@Override
public void update(SpaceBO spaceBO) {
SpaceDO spaceDO = convertToDO(spaceBO);
spaceDO.setGmtCreate(null);
spaceDO.setGmtModified(new Date());
int resultSize;
try {
resultSize = spaceDOMapper.updateByPrimaryKeySelective(spaceDO);
} catch (DuplicateKeyException e) {
throw new BizException(ResultCode.DUPLICATE_KEY_SPACE);
}
if (resultSize == 0) {
throw new BizException(ResultCode.NOT_FOUND_SPACE);
} else if (resultSize != 1) {
throw new IncorrectResultSizeException(resultSize);
}
}
@Override
public void batchCreate(List<HttpInterfaceHeaderBO> httpInterfaceHeaderBOListList, Long httpInterfaceId, HttpHeaderType type) {
httpInterfaceHeaderBOListList.forEach(httpInterfaceHeaderBO -> {
HttpInterfaceHeaderDO httpInterfaceHeaderDO = convertToDO(httpInterfaceHeaderBO, httpInterfaceId, type);
int resultSize;
try {
resultSize = httpInterfaceHeaderDOMapper.insert(httpInterfaceHeaderDO);
} catch (DuplicateKeyException e) {
throw new BizException(ResultCode.DUPLICATE_KEY_HTTP_INTERFACE_HEADER);
}
if (resultSize != 1) {
throw new IncorrectResultSizeException(resultSize);
}
});
}
private void createOrUpdateConfig(final CandidateSnapshot snapshot) throws ModifiedException {
final ConfigMeta configMeta = new ConfigMeta(snapshot.getGroup(), snapshot.getDataId(), snapshot.getProfile());
final ConfigInfoWithoutPublicStatus currentConfig = configDao.findCurrentConfigInfo(configMeta);
final long version = currentConfig == null ? 0 : currentConfig.getVersion();
if (version != snapshot.getBasedVersion()) {
throw new ModifiedException();
} else if (version == 0) {
try {
configDao.create(VersionData.of(snapshot.getEditVersion(), configMeta));
} catch (DuplicateKeyException e) {
throw new ModifiedException();
}
} else {
int update = configDao.update(VersionData.of(snapshot.getEditVersion(), configMeta),
snapshot.getBasedVersion(),
PublicStatus.INUSE);
if (update == 0) {
throw new ModifiedException();
}
}
}
@Override
public Response error(final Throwable throwable) {
logger.error("throwable exception",throwable);
if (throwable instanceof IllegalArgumentException) {
return Responses.error(ErrorCode.BadRequest.getCode(), ErrorCode.BadRequest.getStatus(), throwable.getMessage());
} else if (throwable instanceof DuplicateKeyException) {
return Responses.error(ErrorCode.DuplicateError.getCode(), ErrorCode.DuplicateError.getStatus(), "记录已经存在，请刷新重试");
} else if (throwable instanceof DataIntegrityViolationException) {
return Responses.error(ErrorCode.RuntimeError.getCode(), ErrorCode.RuntimeError.getStatus(), "输入记录不符合要求");
} else if (throwable instanceof InvocationTargetException) {
Throwable targetException = ((InvocationTargetException) throwable).getTargetException();
if (targetException instanceof ServiceException) {
ServiceException serviceException = (ServiceException) targetException;
return Responses.error(ErrorCode.ServiceError.getCode(), serviceException.getStatus(), serviceException.getMessage());
}
return Responses.error(ErrorCode.RuntimeError.getCode(), ErrorCode.RuntimeError.getStatus(), targetException.getMessage());
} else if(throwable instanceof NullPointerException) {
return Responses.error(ErrorCode.RuntimeError.getCode(), ErrorCode.RuntimeError.getStatus(), ((NullPointerException) throwable).toString());
}
return Responses.error(ErrorCode.RuntimeError.getCode(), ErrorCode.RuntimeError.getStatus(),
(StringUtils.isNotBlank(throwable.toString()) ? throwable.toString(): ErrorCode.RuntimeError.getMessage()));
}
private String getOrCreateId(String name) {
int id;
try {
id = dicStore.getId(name);
} catch (EmptyResultDataAccessException e) {
try {
id = dicStore.insertName(name);
} catch (DuplicateKeyException e2) {
id = dicStore.getId(name);
} catch (Exception e3) {
LOG.error("insert name error: {}", name, e3);
throw new RuntimeException("insert name error: " + name, e3);
}
}
return String.format(pattern, id);
}
@PostMapping()
@PreAuthorize("hasAnyRole('ADMIN')")
public ResponseEntity<Response<User>> create(HttpServletRequest request, @RequestBody User user,
BindingResult result) {
Response<User> response = new Response<User>();
try {
validateCreateUser(user, result);
if (result.hasErrors()) {
result.getAllErrors().forEach(error -> response.getErrors().add(error.getDefaultMessage()));
return ResponseEntity.badRequest().body(response);
}
user.setPassword(passwordEncoder.encode(user.getPassword()));
User userPersisted = (User) userService.createOrUpdate(user);
response.setData(userPersisted);
} catch (DuplicateKeyException dE) {
response.getErrors().add("E-mail already registered !");
return ResponseEntity.badRequest().body(response);
} catch (Exception e) {
response.getErrors().add(e.getMessage());
return ResponseEntity.badRequest().body(response);
}
return ResponseEntity.ok(response);
}
@Transactional
public Response update(TestPlan testPlan) {
if (testPlan.getEnableSchedule() == TestPlan.ENABLE_SCHEDULE && StringUtils.isEmpty(testPlan.getCronExpression())) {
// 开启定时任务，表达式不能为空
return Response.fail("cron表达式不能为空");
}
int updateRow;
try {
updateRow = testPlanMapper.updateByPrimaryKeyWithBLOBs(testPlan);
} catch (DuplicateKeyException e) {
return Response.fail("命名冲突");
}
if (testPlan.getEnableSchedule() == TestPlan.ENABLE_SCHEDULE) {
addOrUpdateScheduleTask(testPlan);
} else {
cancelScheduleTask(testPlan.getId());
}
return updateRow == 1 ? Response.success("更新TestPlan成功") : Response.fail("更新TestPlan失败，请稍后重试");
}
@Override
public User create(String email, String passwordOnMd5, User.Role role) {
try {
Date now = Date.from(Instant.now());
User user = new User(email, passwordOnMd5, role);
user.setCreatedAt(now);
user.setUpdatedAt(now);
user.setCreatedBy(sessionManager.exist() ? sessionManager.getUserId() : DefaultCreator);
return userDao.insert(user);
} catch (DuplicateKeyException e) {
throw new DuplicateException("Email {0} is already existed", email);
}
}
@Override
public Product createProduct(Product body) {
if (body.getProductId() < 1) throw new InvalidInputException("Invalid productId: " + body.getProductId());
ProductEntity entity = mapper.apiToEntity(body);
Mono<Product> newEntity = repository.save(entity)
.log()
.onErrorMap(
DuplicateKeyException.class,
ex -> new InvalidInputException("Duplicate key, Product Id: " + body.getProductId()))
.map(e -> mapper.entityToApi(e));
return newEntity.block();
}
@Override
public ServiceVersion add(AddServiceVersionRequestBody body) {
String version = body.getVersion();
String serviceId = body.getServiceId();
String desc = body.getDesc();
String userId = this.getUserId();
// 新增
Date now = new Date();
ServiceVersion serviceVersion = new ServiceVersion();
serviceVersion.setId(SnowflakeIdWorker.getId());
serviceVersion.setVersion(version);
serviceVersion.setServiceId(serviceId);
serviceVersion.setUserId(userId);
serviceVersion.setDescription(desc);
serviceVersion.setCreateTime(now);
serviceVersion.setUpdateTime(now);
if (body instanceof CopyAddServiceVersionRequestBody) {
Date updateTime = ((CopyAddServiceVersionRequestBody) body).getUpdateTime();
serviceVersion.setUpdateTime(updateTime == null ? now : updateTime);
}
try {
this.serviceVersionMapper.insert(serviceVersion);
return serviceVersion;
} catch (DuplicateKeyException ex) {
logger.warn("service version duplicate key " + ex.getMessage());
return this.find(version, serviceId);
}
}
@Override
public int copyConfigs1(List<ServiceConfig> serviceConfigs, String versionId, Map<String, String> oldGrayId2NewGrayId, String path) {
String userId = this.getUserId();
for (ServiceConfig serviceConfig : serviceConfigs) {
serviceConfig.setId(SnowflakeIdWorker.getId());
serviceConfig.setUserId(userId);
serviceConfig.setVersionId(versionId);
String originalPath = serviceConfig.getPath();
String[] split = originalPath.split("/");
String fileName = split[split.length - 1];
StringBuffer sb = new StringBuffer(path);
StringBuffer append = sb.append(fileName);
serviceConfig.setPath(append.toString());
String grayId = serviceConfig.getGrayId();
if (oldGrayId2NewGrayId.containsKey(grayId)){
serviceConfig.setGrayId(oldGrayId2NewGrayId.get(grayId));
}
Date date = new Date();
serviceConfig.setCreateTime(date);
serviceConfig.setUpdateTime(date);
try {
this.serviceConfigMapper.insert(serviceConfig);
} catch (DuplicateKeyException ex) {
logger.warn("service config duplicate key " + ex.getMessage());
}
}
return 0;
}
private <T extends Secret> T save(T credential) {
try {
Date now = Date.from(Instant.now());
credential.setUpdatedAt(now);
credential.setCreatedAt(now);
credential.setCreatedBy(sessionManager.getUserId());
return secretDao.insert(credential);
} catch (DuplicateKeyException e) {
throw new DuplicateException("Credential name {0} is already defined", credential.getName());
}
}
@Override
public Product createProduct(Product body) {
if (body.getProductId() < 1) throw new InvalidInputException("Invalid productId: " + body.getProductId());
ProductEntity entity = mapper.apiToEntity(body);
Mono<Product> newEntity = repository.save(entity)
.log()
.onErrorMap(
DuplicateKeyException.class,
ex -> new InvalidInputException("Duplicate key, Product Id: " + body.getProductId()))
.map(e -> mapper.entityToApi(e));
return newEntity.block();
}
@Test
public void errorCodeTranslation() {
SQLExceptionTranslator sext = new SQLErrorCodeSQLExceptionTranslator(ERROR_CODES);
SQLException badSqlEx = new SQLException("", "", 1);
BadSqlGrammarException bsgex = (BadSqlGrammarException) sext.translate("task", "SQL", badSqlEx);
assertEquals("SQL", bsgex.getSql());
assertEquals(badSqlEx, bsgex.getSQLException());
SQLException invResEx = new SQLException("", "", 4);
InvalidResultSetAccessException irsex = (InvalidResultSetAccessException) sext.translate("task", "SQL", invResEx);
assertEquals("SQL", irsex.getSql());
assertEquals(invResEx, irsex.getSQLException());
checkTranslation(sext, 5, DataAccessResourceFailureException.class);
checkTranslation(sext, 6, DataIntegrityViolationException.class);
checkTranslation(sext, 7, CannotAcquireLockException.class);
checkTranslation(sext, 8, DeadlockLoserDataAccessException.class);
checkTranslation(sext, 9, CannotSerializeTransactionException.class);
checkTranslation(sext, 10, DuplicateKeyException.class);
SQLException dupKeyEx = new SQLException("", "", 10);
DataAccessException dksex = sext.translate("task", "SQL", dupKeyEx);
assertTrue("Not instance of DataIntegrityViolationException",
DataIntegrityViolationException.class.isAssignableFrom(dksex.getClass()));
// Test fallback. We assume that no database will ever return this error code,
// but 07xxx will be bad grammar picked up by the fallback SQLState translator
SQLException sex = new SQLException("", "07xxx", 666666666);
BadSqlGrammarException bsgex2 = (BadSqlGrammarException) sext.translate("task", "SQL2", sex);
assertEquals("SQL2", bsgex2.getSql());
assertEquals(sex, bsgex2.getSQLException());
}
/**
* 处理重复插入异常
*
* @param req
* @param e
* @return
* @throws Exception
*/
@ExceptionHandler(value = DuplicateKeyException.class)
@ResponseBody
public AjaxResult jsonDuplicateKeyErrorHandler(HttpServletRequest req, Exception e) throws Exception {
AjaxResult ajaxResult = new AjaxResult();
e.printStackTrace();
ajaxResult.addError("业务受理失败:" + "数据已添加,请勿重复提交!");
return ajaxResult;
}
@Override
public Product createProduct(Product body) {
if (body.getProductId() < 1) throw new InvalidInputException("Invalid productId: " + body.getProductId());
ProductEntity entity = mapper.apiToEntity(body);
Mono<Product> newEntity = repository.save(entity)
.log()
.onErrorMap(
DuplicateKeyException.class,
ex -> new InvalidInputException("Duplicate key, Product Id: " + body.getProductId()))
.map(e -> mapper.entityToApi(e));
return newEntity.block();
}
@Override
public void add(ExecutorServer executor) throws ExecutorRuntimeException {
Preconditions.checkArgument(executor != null, "executor不能为空");
Preconditions.checkArgument(StringUtils.isNotBlank(executor.getName()), "name不能为空");
Preconditions.checkArgument(StringUtils.isNotBlank(executor.getIp()), "ip不能为空");
executor.setStatus(StatusType.ON.getValue());
try {
executorServerMapper.insert(executor);
} catch (DuplicateKeyException e) {
LOG.error("add executor duplicate, ip:{}, name:{}", executor.getIp(), executor.getName());
throw new ExecutorRuntimeException("已经存在相同ip or name的执行者");
}
}
@Override
public int update(ExecutorServer executor) throws ExecutorRuntimeException {
Preconditions.checkArgument(executor != null, "executor不能为空");
Preconditions.checkArgument(executor.getId() != null, "id不能为空");
try {
return executorServerMapper.update(executor);
} catch (DuplicateKeyException e) {
LOG.error("update executor duplicate, id:{}, ip:{}, name:{}", executor.getId(), executor.getIp(), executor.getName());
throw new ExecutorRuntimeException("已经存在相同ip or name的执行者");
}
}
@Lock
@Transactional(rollbackFor = DSSErrorException.class)
@Override
public void addFlowTaxonomy(DWSFlowTaxonomy dwsFlowTaxonomy,Long projectVersionID) throws DSSErrorException {
try {
flowTaxonomyMapper.insertFlowTaxonomy(dwsFlowTaxonomy);
}catch (DuplicateKeyException e){
logger.info(e.getMessage());
throw new DSSErrorException(90005,"工作流名分类名不能重复");
}
}
@Lock
@Transactional(rollbackFor = DSSErrorException.class)
@Override
public void updateFlowTaxonomy(DWSFlowTaxonomy dwsFlowTaxonomy,Long projectVersionID) throws DSSErrorException {
try {
flowTaxonomyMapper.updateFlowTaxonomy(dwsFlowTaxonomy);
}catch (DuplicateKeyException e){
logger.info(e.getMessage());
throw new DSSErrorException(90005,"工作流名分类名不能重复");
}
}