[DocumentComparison] Java Spring Framework 예제

주의사항

Controller에 기재된대로 api의 request / response 형식을 지켜주세요.

(DB는 예시로 제공될 뿐 원하는 형태로 구성하는 것을 권장드립니다.)

DocumentVersionController.java

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;

import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@RequiredArgsConstructor
@Controller
public class DocumentVersionController {
	private final DocumentVersionService documentVersionService;

    /**
     * 문서 버전 데이터 저장하기
     */
    @PostMapping("/saveDocumentVersionData")
    public String getDocumentVersionData(
			UserInfo userInfo, 
			@RequestParam("docId") final String docId,
			@RequestParam("jsonData") final String jsonData
	) {
        documentVersionService.insertDocumentVersion(userInfo.getUserId(), domainService.getDomainInfo(userInfo).getId(), Long.parseLong(docId), jsonData);
 		return ResponseEntity.ok(Map.of("message", "Document saved successfully."));  
    }

	/**
     * 문서 버전 목록 가져오기
     */
    @PostMapping("/getDocumentVersionList")
    public ResponseEntity<String> getDocumentVersionList(@RequestBody Map<String, Object> request) throws JsonProcessingException {
		long docId = Long.parseLong((String) request.get("docId"));
        
		List<DocumentVersionModel> documentVersionModelList = documentVersionService.getDocumentVersions(docId);
        List<Map<String, Object>> formattedData = documentVersionModelList.stream().map(version -> {
            Map<String, Object> versionData = new HashMap<>();
            versionData.put("id", version.getId());
            versionData.put("date", version.getCreatedAt());
            versionData.put("author", version.getUsername());
            return versionData;
        }).collect(Collectors.toList());

        ObjectMapper objectMapper = new ObjectMapper();
        String jsonResponse = objectMapper.writeValueAsString(formattedData);

        return ResponseEntity.ok()
			.header("Content-Type", "application/json; charset=UTF-8")
			.body(jsonResponse);
    }

    /**
     * 문서 버전 데이터 가져오기
     */
    @PostMapping("/getDocumentVersionData")
    public String getDocumentVersionData(@RequestBody Map<String, Object> request) {
        ObjectMapper objectMapper = new ObjectMapper();
        long id = Long.parseLong((String) request.get("id"));
        String json = documentVersionService.getDocumentVersionJson(id);
 		return ResponseEntity.ok()
				.header("Content-Type", "application/json; charset=UTF-8")
				.body(json);
    }

    /**
     * 문서 버전 데이터 삭제
     */
    @DeleteMapping("/getDocumentVersionData")
    public ResponseEntity<Map<String, Object>> deleteDocumentVersionData(@RequestBody Map<String, Object> request) {
        long id = Long.parseLong((String) request.get("id"));
        documentVersionService.deleteDocumentVersion(id);
        return ResponseEntity.ok(Map.of("message", "Document deleted successfully."));  
    }
}

DocumentVersionService.java

import java.io.*;
import java.nio.charset.Charset;
import java.util.Comparator;
import java.util.List;

@Slf4j
@Service
public class DocumentVersionService {
	@Autowired
	DocumentVersionModelDao documentVersionModelDao;
	@Autowired
	SynapUserInfoDao synapUserInfoDao;
	
	public void insertDocumentVersion(String userId, int domainId, long docId, String json) {
		documentVersionModelDao.insert(new DocumentVersionModel(userId, domainId, docId, json));
	}

	public String getDocumentVersionJson(long id) {
		return documentVersionModelDao.getDocumentVersionById(id).getJson();
	}

	public List<DocumentVersionModel> getDocumentVersions(long docId) {
		List<DocumentVersionModel> documentVersionModelList = documentVersionModelDao.getDocumentVersionByDocId(docId);
		documentVersionModelList.sort(Comparator.comparing(DocumentVersionModel::getUserId));

		String currentUserId = "";
		String targetUsername = "";

		for (DocumentVersionModel model : documentVersionModelList) {
			if (!model.getUserId().equals(currentUserId)) {
				currentUserId = model.getUserId();
				targetUsername = synapUserInfoDao.getUserInfoByUserIdAndDomain(currentUserId, model.getDomainId()).getUserName();
			}
			model.setUsername(targetUsername);
		}
		documentVersionModelList.sort(Comparator.comparing(DocumentVersionModel::getId).reversed());
		return documentVersionModelList;
	}

	public void deleteDocumentVersion(long id) {
		documentVersionModelDao.delete(id);
	}
}

DocumentVersionModelDao.java

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Repository
public class DocumentVersionModelDao extends AbstractDao {
    public void insert(DocumentVersionModel documentVersionModel) {
        insert("DocumentVersion.insert", documentVersionModel);
    }

    public void delete(long id) { delete("DocumentVersion.remove", id); }

    public DocumentVersionModel getDocumentVersionById(long id) {
        Map<String, Object> params = new HashMap<>();
        params.put("id", id);
        return (DocumentVersionModel) select("DocumentVersion.getDocumentVersionById", params);
    }

    public List<DocumentVersionModel> getDocumentVersionByDocId(long docId) {
        return list("DocumentVersion.getDocumentVersionByDocId", docId);
    }
}

AbstractDao.java

import com.ibatis.sqlmap.client.SqlMapClient;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

import javax.annotation.Resource;
import java.util.List;

@SuppressWarnings("deprecation")
public abstract class AbstractDao extends SqlMapClientDaoSupport {
    protected AbstractDao() {

	}

    public final Object insert(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().insert(queryId, parameterObject);
	}

    public final int update(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().update(queryId, parameterObject);
	}

    public final int delete(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().delete(queryId, parameterObject);
	}

    public final Object select(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().queryForObject(queryId, parameterObject);
	}

    @SuppressWarnings("rawtypes")
	public final List list(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().queryForList(queryId, parameterObject);
	}

}

DocumentVersionModel.java

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.sql.Date;

@Data
@NoArgsConstructor
public class DocumentVersionModel implements Serializable {
    private long id;
	private String userId;
	private int domainId;
	private String username;
	private long docId;
	private String json;
	private Date createdAt;

	DocumentVersionModel(String userId, int domainId, long docId, String json) {
		this.userId = userId;
		this.domainId = domainId;
		this.docId = docId;
		this.json = json;
	}
}

DocumentVersion.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="DocumentVersion">
	<resultMap id="documentVersion" class="(DocumentVersionModel path)">
		<result property="id" column="id" columnIndex="1"/>
		<result property="userId" column="user_id" columnIndex="2"/>
		<result property="domainId" column="domain_id" columnIndex="3"/>
		<result property="docId" column="doc_id" columnIndex="4"/>
		<result property="json" column="json" columnIndex="5"/>
		<result property="createdAt" column="created_at" columnIndex="6"/>
	</resultMap>
	<resultMap id="documentVersionList" class="(DocumentVersionModel path)">
		<result property="id" column="id" columnIndex="1"/>
		<result property="userId" column="user_id" columnIndex="2"/>
		<result property="domainId" column="domain_id" columnIndex="3"/>
		<result property="docId" column="doc_id" columnIndex="4"/>
		<result property="createdAt" column="created_at" columnIndex="5"/>
	</resultMap>

	<insert id="insert">
		INSERT INTO
			document_version(user_id, domain_id, doc_id, json, created_at)
		VALUES
			(#userId#, #domainId#, #docId# , #json#, SYSDATE())
	</insert>
	
    <delete id="remove">
		DELETE FROM document_version
		WHERE id = #id#
	</delete>

	<select id="getDocumentVersionById" resultMap="documentVersion">
		SELECT id, user_id, domain_id, doc_id, json, created_at
		FROM document_version
		WHERE
			id = #id#
	</select>

	<select id="getDocumentVersionByDocId" resultClass="java.util.List" resultMap="documentVersionList">
		SELECT id, user_id, domain_id, doc_id, created_at
		FROM document_version
		WHERE
			doc_id = #docId#
		ORDER BY id DESC
		LIMIT 500
	</select>
</sqlMap>

테이블 구조 (예시)

CREATE TABLE `document_version` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` varchar(100) COLLATE utf8mb4_unicode_ci NOT NULL,
  `domain_id` int(11) NOT NULL DEFAULT 1,
  `doc_id` bigint(20) NOT NULL,
  `json` longtext COLLATE utf8mb4_unicode_ci NOT NULL,
  `created_at` datetime NOT NULL DEFAULT current_timestamp(),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=671 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

Space shortcuts

Page tree