From dcfb4066795839e59161921c7767b46addf76465 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=9E=AC=EC=9A=B0?= <Akaps6768@gmail.com>
Date: Thu, 24 Oct 2024 21:36:09 +0900
Subject: [PATCH 1/8] =?UTF-8?q?Nginx=20=EC=84=A4=EC=A0=95=EC=9D=B4=20?=
 =?UTF-8?q?=EB=B0=98=EC=98=81=EB=90=98=EC=A7=80=20=EC=95=8A=EB=8A=94=20?=
 =?UTF-8?q?=EB=B2=84=EA=B7=B8=20=EC=88=98=EC=A0=95=20(#882)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: fix typo

* chore: fix typo

* chore: fix zdd

* chore: fix zdd

* chore: fix zdd

* chore: fix zdd

* chore: remove export hostname

* chore: remove export hostname

* chore: remove nginx config

* chore: fix deploy script

* chore: fix deploy script
---
 backend/submodules/private | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/submodules/private b/backend/submodules/private
index 9968b84a3..c434d76a4 160000
--- a/backend/submodules/private
+++ b/backend/submodules/private
@@ -1 +1 @@
-Subproject commit 9968b84a38d1db534354a0e8d71bfed7180c384c
+Subproject commit c434d76a4712b6d3299525142b963bc0cbd8ee74

From 22813d79231812f3ac1330e559d6e0f62325708b Mon Sep 17 00:00:00 2001
From: Moly <102847513+jminkkk@users.noreply.github.com>
Date: Thu, 7 Nov 2024 08:30:45 +0900
Subject: [PATCH 2/8] =?UTF-8?q?QueryDSL=20=EB=8F=84=EC=9E=85=20(#869)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 backend/build.gradle                          |   4 +
 .../repository/CategoryJpaRepository.java     |  10 +-
 .../repository/CategoryRepository.java        |  36 ++++-
 .../global/querydsl/QueryDSLConfig.java       |  21 +++
 .../codezap/global/rds/DataSourceConfig.java  |   1 -
 .../likes/repository/LikesJpaRepository.java  |  14 +-
 .../repository/LikesQueryDslRepository.java   |  25 ++++
 .../likes/repository/LikesRepository.java     |  35 +++--
 .../member/controller/MemberController.java   |  13 +-
 .../controller/SpringDocMemberController.java |   9 +-
 .../repository/MemberJpaRepository.java       |  26 +---
 .../repository/MemberQueryDSLRepository.java  |  26 ++++
 .../member/repository/MemberRepository.java   |  35 ++++-
 .../codezap/member/service/MemberService.java |   2 -
 .../tag/repository/TagJpaRepository.java      |  15 +-
 .../codezap/tag/repository/TagRepository.java |  32 +++-
 .../repository/TemplateTagJpaRepository.java  |  51 +------
 .../TemplateTagQueryDSLRepository.java        |  65 ++++++++
 .../tag/repository/TemplateTagRepository.java |  46 ++++--
 .../codezap/template/domain/TemplateTag.java  |   2 +-
 .../FullTextFunctionContributor.java          |  20 +++
 .../FullTextSearchMySQLDialect.java           |  76 +++++-----
 .../repository/SourceCodeJpaRepository.java   |  24 +--
 .../SourceCodeQueryDSLRepository.java         |  25 ++++
 .../repository/SourceCodeRepository.java      |  51 +++++--
 .../repository/TemplateJpaRepository.java     |  17 +--
 .../TemplateOrderSpecifierUtils.java          |  56 +++++++
 .../TemplateQueryDSLRepository.java           |  89 +++++++++++
 .../repository/TemplateRepository.java        |  54 +++++--
 .../TemplateSearchExpressionProvider.java     |  74 +++++++++
 .../repository/TemplateSpecification.java     | 119 ---------------
 .../repository/ThumbnailJpaRepository.java    |  41 +----
 .../ThumbnailQueryDSLRepository.java          |  42 ++++++
 .../repository/ThumbnailRepository.java       |  33 +++-
 .../FullTextSearchSearchStrategy.java         |  43 ++++++
 .../strategy/LikeSearchStrategy.java          |  42 ++++++
 .../repository/strategy/SearchStrategy.java   |   8 +
 .../template/service/TemplateService.java     |   4 +-
 ...g.hibernate.boot.model.FunctionContributor |   1 +
 backend/src/main/resources/application-db.yml |   3 -
 .../src/main/resources/application-local.yml  |   3 -
 .../BasicAuthCredentialProviderTest.java      |   1 -
 .../repository/CategoryRepositoryTest.java    |   4 +-
 .../global/repository/JpaRepositoryTest.java  |  23 ---
 .../global/repository/RepositoryTest.java     |  35 +++++
 ...toryTest.java => LikesRepositoryTest.java} |   6 +-
 ...oryTest.java => MemberRepositoryTest.java} |   6 +-
 ...sitoryTest.java => TagRepositoryTest.java} |  44 +-----
 ...st.java => TemplateTagRepositoryTest.java} |   6 +-
 .../repository/SourceCodeRepositoryTest.java  |   4 +-
 ...yTest.java => TemplateRepositoryTest.java} |   6 +-
 ...java => TemplateSearchRepositoryTest.java} | 141 ++++++++++++------
 .../repository/ThumbnailRepositoryTest.java   |   4 +-
 .../TemplateApplicationServiceTest.java       |   5 +-
 54 files changed, 1014 insertions(+), 564 deletions(-)
 create mode 100644 backend/src/main/java/codezap/global/querydsl/QueryDSLConfig.java
 create mode 100644 backend/src/main/java/codezap/likes/repository/LikesQueryDslRepository.java
 create mode 100644 backend/src/main/java/codezap/member/repository/MemberQueryDSLRepository.java
 create mode 100644 backend/src/main/java/codezap/tag/repository/TemplateTagQueryDSLRepository.java
 create mode 100644 backend/src/main/java/codezap/template/repository/FullTextFunctionContributor.java
 create mode 100644 backend/src/main/java/codezap/template/repository/SourceCodeQueryDSLRepository.java
 create mode 100644 backend/src/main/java/codezap/template/repository/TemplateOrderSpecifierUtils.java
 create mode 100644 backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java
 create mode 100644 backend/src/main/java/codezap/template/repository/TemplateSearchExpressionProvider.java
 delete mode 100644 backend/src/main/java/codezap/template/repository/TemplateSpecification.java
 create mode 100644 backend/src/main/java/codezap/template/repository/ThumbnailQueryDSLRepository.java
 create mode 100644 backend/src/main/java/codezap/template/repository/strategy/FullTextSearchSearchStrategy.java
 create mode 100644 backend/src/main/java/codezap/template/repository/strategy/LikeSearchStrategy.java
 create mode 100644 backend/src/main/java/codezap/template/repository/strategy/SearchStrategy.java
 create mode 100644 backend/src/main/resources/META-INF/services/org.hibernate.boot.model.FunctionContributor
 delete mode 100644 backend/src/test/java/codezap/global/repository/JpaRepositoryTest.java
 create mode 100644 backend/src/test/java/codezap/global/repository/RepositoryTest.java
 rename backend/src/test/java/codezap/likes/repository/{LikesJpaRepositoryTest.java => LikesRepositoryTest.java} (98%)
 rename backend/src/test/java/codezap/member/repository/{MemberJpaRepositoryTest.java => MemberRepositoryTest.java} (97%)
 rename backend/src/test/java/codezap/tag/repository/{TagJpaRepositoryTest.java => TagRepositoryTest.java} (68%)
 rename backend/src/test/java/codezap/tag/repository/{TemplateTagJpaRepositoryTest.java => TemplateTagRepositoryTest.java} (98%)
 rename backend/src/test/java/codezap/template/repository/{TemplateJpaRepositoryTest.java => TemplateRepositoryTest.java} (97%)
 rename backend/src/test/java/codezap/template/repository/{TemplateSearchJpaRepositoryTest.java => TemplateSearchRepositoryTest.java} (68%)

diff --git a/backend/build.gradle b/backend/build.gradle
index 8181f00f3..612c5dfe9 100644
--- a/backend/build.gradle
+++ b/backend/build.gradle
@@ -33,6 +33,10 @@ dependencies {
     runtimeOnly 'com.mysql:mysql-connector-j:9.0.0'
     implementation 'org.flywaydb:flyway-core'
     implementation 'org.flywaydb:flyway-mysql'
+    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
+    annotationProcessor 'com.querydsl:querydsl-apt:5.0.0:jakarta'
+    annotationProcessor 'jakarta.persistence:jakarta.persistence-api:3.1.0'
+    annotationProcessor 'jakarta.annotation:jakarta.annotation-api:2.1.1'
 
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'io.rest-assured:rest-assured:5.5.0'
diff --git a/backend/src/main/java/codezap/category/repository/CategoryJpaRepository.java b/backend/src/main/java/codezap/category/repository/CategoryJpaRepository.java
index d692f1a48..a2308ba9d 100644
--- a/backend/src/main/java/codezap/category/repository/CategoryJpaRepository.java
+++ b/backend/src/main/java/codezap/category/repository/CategoryJpaRepository.java
@@ -5,17 +5,9 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 
 import codezap.category.domain.Category;
-import codezap.global.exception.CodeZapException;
-import codezap.global.exception.ErrorCode;
 import codezap.member.domain.Member;
 
-@SuppressWarnings("unused")
-public interface CategoryJpaRepository extends CategoryRepository, JpaRepository<Category, Long> {
-
-    default Category fetchById(Long id) {
-        return findById(id).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 카테고리가 존재하지 않습니다."));
-    }
+public interface CategoryJpaRepository extends JpaRepository<Category, Long> {
 
     List<Category> findAllByMemberIdOrderById(Long memberId);
 
diff --git a/backend/src/main/java/codezap/category/repository/CategoryRepository.java b/backend/src/main/java/codezap/category/repository/CategoryRepository.java
index debb78f08..85b4178d2 100644
--- a/backend/src/main/java/codezap/category/repository/CategoryRepository.java
+++ b/backend/src/main/java/codezap/category/repository/CategoryRepository.java
@@ -2,20 +2,42 @@
 
 import java.util.List;
 
+import org.springframework.stereotype.Repository;
+
 import codezap.category.domain.Category;
+import codezap.global.exception.CodeZapException;
+import codezap.global.exception.ErrorCode;
 import codezap.member.domain.Member;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class CategoryRepository {
 
-public interface CategoryRepository {
+    private final CategoryJpaRepository categoryJpaRepository;
 
-    Category fetchById(Long id);
+    public Category save(Category category) {
+        return categoryJpaRepository.save(category);
+    }
 
-    List<Category> findAllByMemberIdOrderById(Long memberId);
+    public Category fetchById(Long id) {
+        return categoryJpaRepository.findById(id).orElseThrow(
+                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 카테고리가 존재하지 않습니다."));
+    }
 
-    List<Category> findAll();
+    public List<Category> findAllByMemberIdOrderById(Long memberId) {
+        return categoryJpaRepository.findAllByMemberIdOrderById(memberId);
+    }
 
-    boolean existsByNameAndMember(String categoryName, Member member);
+    public List<Category> findAll() {
+        return categoryJpaRepository.findAll();
+    }
 
-    Category save(Category category);
+    public boolean existsByNameAndMember(String categoryName, Member member) {
+        return categoryJpaRepository.existsByNameAndMember(categoryName, member);
+    }
 
-    void deleteById(Long id);
+    public void deleteById(Long id) {
+        categoryJpaRepository.deleteById(id);
+    }
 }
diff --git a/backend/src/main/java/codezap/global/querydsl/QueryDSLConfig.java b/backend/src/main/java/codezap/global/querydsl/QueryDSLConfig.java
new file mode 100644
index 000000000..384b4b8bb
--- /dev/null
+++ b/backend/src/main/java/codezap/global/querydsl/QueryDSLConfig.java
@@ -0,0 +1,21 @@
+package codezap.global.querydsl;
+
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+@Configuration
+public class QueryDSLConfig {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+
+    @Bean
+    public JPAQueryFactory jpaQueryFactory() {
+        return new JPAQueryFactory(entityManager);
+    }
+}
diff --git a/backend/src/main/java/codezap/global/rds/DataSourceConfig.java b/backend/src/main/java/codezap/global/rds/DataSourceConfig.java
index fa1f9a6d6..ea1140995 100644
--- a/backend/src/main/java/codezap/global/rds/DataSourceConfig.java
+++ b/backend/src/main/java/codezap/global/rds/DataSourceConfig.java
@@ -11,7 +11,6 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.DependsOn;
 import org.springframework.context.annotation.Primary;
-import org.springframework.context.annotation.Profile;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;
 
diff --git a/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java b/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java
index 4c2e1d265..196dadf12 100644
--- a/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java
+++ b/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java
@@ -1,22 +1,22 @@
 package codezap.likes.repository;
 
-import java.util.List;
-
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
 import codezap.likes.domain.Likes;
+import codezap.member.domain.Member;
 import codezap.template.domain.Template;
 
-public interface LikesJpaRepository extends LikesRepository, JpaRepository<Likes, Long> {
+public interface LikesJpaRepository extends JpaRepository<Likes, Long> {
+
+    void deleteByMemberAndTemplate(Member member, Template template);
+
+    boolean existsByMemberAndTemplate(Member member, Template template);
 
-    @Modifying(clearAutomatically = true)
-    @Query("DELETE FROM Likes l WHERE l.template.id in :templateIds")
-    void deleteAllByTemplateIds(@Param(value = "templateIds") List<Long> templateIds);
+    long countByTemplate(Template template);
 
     @Query("""
             SELECT l.template
diff --git a/backend/src/main/java/codezap/likes/repository/LikesQueryDslRepository.java b/backend/src/main/java/codezap/likes/repository/LikesQueryDslRepository.java
new file mode 100644
index 000000000..dac87d865
--- /dev/null
+++ b/backend/src/main/java/codezap/likes/repository/LikesQueryDslRepository.java
@@ -0,0 +1,25 @@
+package codezap.likes.repository;
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.likes.domain.QLikes;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class LikesQueryDslRepository {
+
+    private final JPAQueryFactory jpaQueryFactory;
+
+    @Modifying(clearAutomatically = true)
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        jpaQueryFactory.delete(QLikes.likes)
+            .where(QLikes.likes.template.id.in(templateIds))
+            .execute();
+    }
+}
diff --git a/backend/src/main/java/codezap/likes/repository/LikesRepository.java b/backend/src/main/java/codezap/likes/repository/LikesRepository.java
index 358c18c9b..1c4e1b690 100644
--- a/backend/src/main/java/codezap/likes/repository/LikesRepository.java
+++ b/backend/src/main/java/codezap/likes/repository/LikesRepository.java
@@ -4,24 +4,41 @@
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
 
 import codezap.likes.domain.Likes;
 import codezap.member.domain.Member;
 import codezap.template.domain.Template;
+import lombok.RequiredArgsConstructor;
 
-public interface LikesRepository {
+@Repository
+@RequiredArgsConstructor
+public class LikesRepository {
 
-    Likes save(Likes likes);
+    private final LikesJpaRepository likesJpaRepository;
+    private final LikesQueryDslRepository likesQueryDslRepository;
 
-    boolean existsByMemberAndTemplate(Member member, Template template);
+    public Likes save(Likes likes) {
+        return likesJpaRepository.save(likes);
+    }
 
-    long countByTemplate(Template template);
+    public boolean existsByMemberAndTemplate(Member member, Template template) {
+        return likesJpaRepository.existsByMemberAndTemplate(member, template);
+    }
 
-    void deleteByMemberAndTemplate(Member member, Template template);
+    public long countByTemplate(Template template) {
+        return likesJpaRepository.countByTemplate(template);
+    }
 
-    void deleteAllByTemplateIds(List<Long> templateIds);
+    public void deleteByMemberAndTemplate(Member member, Template template) {
+        likesJpaRepository.deleteByMemberAndTemplate(member, template);
+    }
 
-    Page<Template> findAllByMemberId(Long memberId, Pageable pageable);
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        likesQueryDslRepository.deleteAllByTemplateIds(templateIds);
+    }
+
+    public Page<Template> findAllByMemberId(Long memberId, Pageable pageable) {
+        return likesJpaRepository.findAllByMemberId(memberId, pageable);
+    }
 }
diff --git a/backend/src/main/java/codezap/member/controller/MemberController.java b/backend/src/main/java/codezap/member/controller/MemberController.java
index 5349f21e4..211b3d07f 100644
--- a/backend/src/main/java/codezap/member/controller/MemberController.java
+++ b/backend/src/main/java/codezap/member/controller/MemberController.java
@@ -1,11 +1,9 @@
 package codezap.member.controller;
 
-import codezap.member.dto.request.SignupRequest;
-import codezap.member.dto.response.FindMemberResponse;
-import codezap.member.service.MemberService;
-import jakarta.validation.Valid;
 import java.net.URI;
-import lombok.RequiredArgsConstructor;
+
+import jakarta.validation.Valid;
+
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -16,6 +14,11 @@
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
 
+import codezap.member.dto.request.SignupRequest;
+import codezap.member.dto.response.FindMemberResponse;
+import codezap.member.service.MemberService;
+import lombok.RequiredArgsConstructor;
+
 @RestController
 @RequiredArgsConstructor
 public class MemberController implements SpringDocMemberController {
diff --git a/backend/src/main/java/codezap/member/controller/SpringDocMemberController.java b/backend/src/main/java/codezap/member/controller/SpringDocMemberController.java
index 1ef3644cc..893e19969 100644
--- a/backend/src/main/java/codezap/member/controller/SpringDocMemberController.java
+++ b/backend/src/main/java/codezap/member/controller/SpringDocMemberController.java
@@ -1,5 +1,10 @@
 package codezap.member.controller;
 
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+
 import codezap.global.swagger.error.ApiErrorResponse;
 import codezap.global.swagger.error.ErrorCase;
 import codezap.member.dto.request.SignupRequest;
@@ -7,10 +12,6 @@
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestParam;
 
 @Tag(name = "회원 API", description = "회원 API")
 public interface SpringDocMemberController {
diff --git a/backend/src/main/java/codezap/member/repository/MemberJpaRepository.java b/backend/src/main/java/codezap/member/repository/MemberJpaRepository.java
index 0d5e1d0da..5fefe7289 100644
--- a/backend/src/main/java/codezap/member/repository/MemberJpaRepository.java
+++ b/backend/src/main/java/codezap/member/repository/MemberJpaRepository.java
@@ -3,34 +3,10 @@
 import java.util.Optional;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
-import codezap.global.exception.CodeZapException;
-import codezap.global.exception.ErrorCode;
 import codezap.member.domain.Member;
 
-@SuppressWarnings("unused")
-public interface MemberJpaRepository extends MemberRepository, JpaRepository<Member, Long> {
-
-    default Member fetchById(Long id) {
-        return findById(id).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 멤버가 존재하지 않습니다."));
-    }
-
-    default Member fetchByName(String name) {
-        return findByName(name)
-                .orElseThrow(() -> new CodeZapException(ErrorCode.UNAUTHORIZED_ID, "존재하지 않는 아이디 " + name + " 입니다."));
-    }
-
-    default Member fetchByTemplateId(Long templateId) {
-        return findByTemplateId(templateId)
-                .orElseThrow(() -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "템플릿에 대한 멤버가 존재하지 않습니다."));
-    }
-
-    @Query("SELECT t.member FROM Template t WHERE t.id = :templateId")
-    Optional<Member> findByTemplateId(@Param("templateId") Long templateId);
-
+public interface MemberJpaRepository extends JpaRepository<Member, Long> {
     Optional<Member> findByName(String name);
 
     boolean existsByName(String name);
diff --git a/backend/src/main/java/codezap/member/repository/MemberQueryDSLRepository.java b/backend/src/main/java/codezap/member/repository/MemberQueryDSLRepository.java
new file mode 100644
index 000000000..1fe8fef74
--- /dev/null
+++ b/backend/src/main/java/codezap/member/repository/MemberQueryDSLRepository.java
@@ -0,0 +1,26 @@
+package codezap.member.repository;
+
+import static codezap.template.domain.QTemplate.template;
+
+import java.util.Optional;
+
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.member.domain.Member;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class MemberQueryDSLRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    public Optional<Member> findByTemplateId(Long templateId) {
+        return Optional.ofNullable(queryFactory.select(template.member)
+                .from(template)
+                .where(template.id.eq(templateId))
+                .fetchOne());
+    }
+}
diff --git a/backend/src/main/java/codezap/member/repository/MemberRepository.java b/backend/src/main/java/codezap/member/repository/MemberRepository.java
index 49f2960d3..e44f516c6 100644
--- a/backend/src/main/java/codezap/member/repository/MemberRepository.java
+++ b/backend/src/main/java/codezap/member/repository/MemberRepository.java
@@ -1,16 +1,39 @@
 package codezap.member.repository;
 
+import org.springframework.stereotype.Repository;
+
+import codezap.global.exception.CodeZapException;
+import codezap.global.exception.ErrorCode;
 import codezap.member.domain.Member;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class MemberRepository {
 
-public interface MemberRepository {
+    private final MemberJpaRepository memberJpaRepository;
+    private final MemberQueryDSLRepository memberQueryDSLRepository;
 
-    Member fetchById(Long id);
+    public Member fetchById(Long id) {
+        return memberJpaRepository.findById(id).orElseThrow(
+                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 멤버가 존재하지 않습니다."));
+    }
 
-    Member fetchByName(String name);
+    public Member fetchByName(String name) {
+        return memberJpaRepository.findByName(name)
+                .orElseThrow(() -> new CodeZapException(ErrorCode.UNAUTHORIZED_ID, "존재하지 않는 아이디 " + name + " 입니다."));
+    }
 
-    Member fetchByTemplateId(Long templateId);
+    public Member fetchByTemplateId(Long templateId) {
+        return memberQueryDSLRepository.findByTemplateId(templateId)
+                .orElseThrow(() -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "템플릿에 대한 멤버가 존재하지 않습니다."));
+    }
 
-    boolean existsByName(String name);
+    public boolean existsByName(String name) {
+        return memberJpaRepository.existsByName(name);
+    }
 
-    Member save(Member member);
+    public Member save(Member member) {
+        return memberJpaRepository.save(member);
+    }
 }
diff --git a/backend/src/main/java/codezap/member/service/MemberService.java b/backend/src/main/java/codezap/member/service/MemberService.java
index a57c47336..cbf83c30a 100644
--- a/backend/src/main/java/codezap/member/service/MemberService.java
+++ b/backend/src/main/java/codezap/member/service/MemberService.java
@@ -1,7 +1,5 @@
 package codezap.member.service;
 
-import java.util.Objects;
-
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
diff --git a/backend/src/main/java/codezap/tag/repository/TagJpaRepository.java b/backend/src/main/java/codezap/tag/repository/TagJpaRepository.java
index cbb826afe..d48252878 100644
--- a/backend/src/main/java/codezap/tag/repository/TagJpaRepository.java
+++ b/backend/src/main/java/codezap/tag/repository/TagJpaRepository.java
@@ -7,22 +7,9 @@
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
-import codezap.global.exception.CodeZapException;
-import codezap.global.exception.ErrorCode;
 import codezap.tag.domain.Tag;
 
-@SuppressWarnings("unused")
-public interface TagJpaRepository extends TagRepository, JpaRepository<Tag, Long> {
-
-    default Tag fetchById(Long id) {
-        return findById(id).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 태그가 존재하지 않습니다."));
-    }
-
-    default Tag fetchByName(String name) {
-        return findByName(name).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "이름이 " + name + "인 태그는 존재하지 않습니다."));
-    }
+public interface TagJpaRepository extends JpaRepository<Tag, Long> {
 
     @Query(value = "SELECT * FROM tag WHERE tag.name = BINARY :name", nativeQuery = true)
     Optional<Tag> findByName(@Param("name") String name);
diff --git a/backend/src/main/java/codezap/tag/repository/TagRepository.java b/backend/src/main/java/codezap/tag/repository/TagRepository.java
index bc547bda9..23368fd44 100644
--- a/backend/src/main/java/codezap/tag/repository/TagRepository.java
+++ b/backend/src/main/java/codezap/tag/repository/TagRepository.java
@@ -3,19 +3,37 @@
 import java.util.List;
 import java.util.Optional;
 
+import org.springframework.stereotype.Repository;
+
+import codezap.global.exception.CodeZapException;
+import codezap.global.exception.ErrorCode;
 import codezap.tag.domain.Tag;
+import lombok.RequiredArgsConstructor;
 
-public interface TagRepository {
+@Repository
+@RequiredArgsConstructor
+public class TagRepository {
 
-    Tag fetchById(Long id);
+    private final TagJpaRepository tagJpaRepository;
 
-    Tag fetchByName(String name);
+    public Tag fetchById(Long id) {
+        return tagJpaRepository.findById(id).orElseThrow(
+                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 태그가 존재하지 않습니다."));
+    }
 
-    Optional<Tag> findByName(String name);
+    public Optional<Tag> findByName(String name) {
+        return tagJpaRepository.findByName(name);
+    }
 
-    List<Tag> findAllByNames(List<String> names);
+    public List<Tag> findAllByNames(List<String> names) {
+        return tagJpaRepository.findAllByNames(names);
+    }
 
-    Tag save(Tag tag);
+    public Tag save(Tag tag) {
+        return tagJpaRepository.save(tag);
+    }
 
-    <S extends Tag> List<S> saveAll(Iterable<S> entities);
+    public List<Tag> saveAll(Iterable<Tag> entities) {
+        return tagJpaRepository.saveAll(entities);
+    }
 }
diff --git a/backend/src/main/java/codezap/tag/repository/TemplateTagJpaRepository.java b/backend/src/main/java/codezap/tag/repository/TemplateTagJpaRepository.java
index 0fb949b8b..ff85eb90e 100644
--- a/backend/src/main/java/codezap/tag/repository/TemplateTagJpaRepository.java
+++ b/backend/src/main/java/codezap/tag/repository/TemplateTagJpaRepository.java
@@ -1,57 +1,10 @@
 package codezap.tag.repository;
 
-import java.util.List;
-
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Modifying;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
-import codezap.tag.domain.Tag;
-import codezap.template.domain.Template;
 import codezap.template.domain.TemplateTag;
 
-@SuppressWarnings("unused")
-public interface TemplateTagJpaRepository extends TemplateTagRepository, JpaRepository<TemplateTag, Long> {
-
-    @Query("""
-            SELECT t
-            FROM Tag t
-            JOIN TemplateTag tt ON t.id = tt.id.tagId
-            WHERE tt.template = :template
-            """)
-    List<Tag> findAllTagsByTemplate(@Param("template") Template template);
-
-    @Query("""
-            SELECT tt, t
-            FROM TemplateTag tt
-            JOIN FETCH tt.tag t
-            WHERE tt.id.templateId = :templateId
-            """)
-    List<TemplateTag> findAllByTemplateId(@Param("templateId") Long templateId);
-
-    @Query("""
-            SELECT tt, t
-            FROM TemplateTag tt
-            JOIN FETCH tt.tag t
-            WHERE tt.id.templateId in :templateIds
-            """)
-    List<TemplateTag> findAllByTemplateIdsIn(@Param("templateIds") List<Long> templateIds);
-
-    @Query("""
-            SELECT DISTINCT t
-            FROM Tag t
-            WHERE t.id IN (
-                SELECT DISTINCT tt.id.tagId
-                FROM TemplateTag tt
-                WHERE tt.id.templateId IN (
-                    SELECT te.id FROM Template te WHERE te.member.id = :memberId
-                )
-            )
-            """)
-    List<Tag> findAllTagDistinctByMemberId(@Param("memberId") Long memberId);
+public interface TemplateTagJpaRepository extends JpaRepository<TemplateTag, Long> {
 
-    @Modifying(clearAutomatically = true)
-    @Query("DELETE FROM TemplateTag t WHERE t.template.id in :templateIds")
-    void deleteAllByTemplateIds(@Param("templateIds") List<Long> templateIds);
+    void deleteAllByTemplateId(Long templateId);
 }
diff --git a/backend/src/main/java/codezap/tag/repository/TemplateTagQueryDSLRepository.java b/backend/src/main/java/codezap/tag/repository/TemplateTagQueryDSLRepository.java
new file mode 100644
index 000000000..043d82a82
--- /dev/null
+++ b/backend/src/main/java/codezap/tag/repository/TemplateTagQueryDSLRepository.java
@@ -0,0 +1,65 @@
+package codezap.tag.repository;
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.tag.domain.QTag;
+import codezap.tag.domain.Tag;
+import codezap.template.domain.QTemplate;
+import codezap.template.domain.QTemplateTag;
+import codezap.template.domain.Template;
+import codezap.template.domain.TemplateTag;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class TemplateTagQueryDSLRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    public List<Tag> findAllTagsByTemplate(Template template) {
+        return queryFactory.selectFrom(QTag.tag)
+                .innerJoin(QTemplateTag.templateTag)
+                .on(QTag.tag.id.eq(QTemplateTag.templateTag.id.tagId))
+                .where(QTemplateTag.templateTag.template.eq(template))
+                .fetch();
+    }
+
+    public List<TemplateTag> findAllByTemplateId(Long templateId) {
+        return queryFactory.selectFrom(QTemplateTag.templateTag)
+                .innerJoin(QTemplateTag.templateTag.tag).fetchJoin()
+                .where(QTemplateTag.templateTag.id.templateId.eq(templateId))
+                .fetch();
+    }
+
+    public List<TemplateTag> findAllByTemplateIdsIn(List<Long> templateIds) {
+        return queryFactory.selectFrom(QTemplateTag.templateTag)
+                .innerJoin(QTemplateTag.templateTag.tag).fetchJoin()
+                .where(QTemplateTag.templateTag.id.templateId.in(templateIds))
+                .fetch();
+    }
+
+    public List<Tag> findAllTagDistinctByMemberId(Long memberId) {
+        QTag tag = QTag.tag;
+        QTemplateTag templateTag = QTemplateTag.templateTag;
+        QTemplate template = QTemplate.template;
+
+        return queryFactory.selectDistinct(tag)
+                .from(tag)
+                .join(templateTag).on(tag.id.eq(templateTag.id.tagId))
+                .join(template).on(templateTag.id.templateId.eq(template.id))
+                .where(template.member.id.eq(memberId))
+                .fetch();
+    }
+
+    @Modifying(clearAutomatically = true)
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        queryFactory.delete(QTemplateTag.templateTag)
+                .where(QTemplateTag.templateTag.id.templateId.in(templateIds))
+                .execute();
+    }
+}
diff --git a/backend/src/main/java/codezap/tag/repository/TemplateTagRepository.java b/backend/src/main/java/codezap/tag/repository/TemplateTagRepository.java
index 2983b2213..86a64caf1 100644
--- a/backend/src/main/java/codezap/tag/repository/TemplateTagRepository.java
+++ b/backend/src/main/java/codezap/tag/repository/TemplateTagRepository.java
@@ -2,27 +2,53 @@
 
 import java.util.List;
 
+import org.springframework.stereotype.Repository;
+
 import codezap.tag.domain.Tag;
 import codezap.template.domain.Template;
 import codezap.template.domain.TemplateTag;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class TemplateTagRepository {
 
-public interface TemplateTagRepository {
+    private final TemplateTagJpaRepository templateTagJpaRepository;
+    private final TemplateTagQueryDSLRepository templateTagQueryDSLRepository;
 
-    List<TemplateTag> findAllByTemplate(Template template);
+    public List<TemplateTag> findAllByTemplate(Template template) {
+        return templateTagQueryDSLRepository.findAllByTemplateId(template.getId());
+    }
 
-    List<Tag> findAllTagsByTemplate(Template template);
+    public List<Tag> findAllTagsByTemplate(Template template) {
+        return templateTagQueryDSLRepository.findAllTagsByTemplate(template);
+    }
 
-    List<Tag> findAllTagDistinctByMemberId(Long memberId);
+    public List<Tag> findAllTagDistinctByMemberId(Long memberId) {
+        return templateTagQueryDSLRepository.findAllTagDistinctByMemberId(memberId);
+    }
 
-    List<TemplateTag> findAllByTemplateId(Long templateId);
+    public List<TemplateTag> findAllByTemplateId(Long templateId) {
+        return templateTagQueryDSLRepository.findAllByTemplateId(templateId);
+    }
 
-    List<TemplateTag> findAllByTemplateIdsIn(List<Long> templateIds);
+    public List<TemplateTag> findAllByTemplateIdsIn(List<Long> templateIds) {
+        return templateTagQueryDSLRepository.findAllByTemplateIdsIn(templateIds);
+    }
 
-    TemplateTag save(TemplateTag templateTag);
+    public TemplateTag save(TemplateTag templateTag) {
+        return templateTagJpaRepository.save(templateTag);
+    }
 
-    <S extends TemplateTag> List<S> saveAll(Iterable<S> entities);
+    public List<TemplateTag> saveAll(Iterable<TemplateTag> entities) {
+        return templateTagJpaRepository.saveAll(entities);
+    }
 
-    void deleteAllByTemplateId(Long templateId);
+    public void deleteAllByTemplateId(Long templateId) {
+        templateTagJpaRepository.deleteAllByTemplateId(templateId);
+    }
 
-    void deleteAllByTemplateIds(List<Long> templateIds);
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        templateTagQueryDSLRepository.deleteAllByTemplateIds(templateIds);
+    }
 }
diff --git a/backend/src/main/java/codezap/template/domain/TemplateTag.java b/backend/src/main/java/codezap/template/domain/TemplateTag.java
index a19d8800c..278161ae3 100644
--- a/backend/src/main/java/codezap/template/domain/TemplateTag.java
+++ b/backend/src/main/java/codezap/template/domain/TemplateTag.java
@@ -29,7 +29,7 @@ public class TemplateTag extends BaseTimeEntity {
     @AllArgsConstructor
     @Getter
     @EqualsAndHashCode
-    private static class TemplateTagId implements Serializable {
+    protected static class TemplateTagId implements Serializable {
         private Long templateId;
         private Long tagId;
     }
diff --git a/backend/src/main/java/codezap/template/repository/FullTextFunctionContributor.java b/backend/src/main/java/codezap/template/repository/FullTextFunctionContributor.java
new file mode 100644
index 000000000..7a6d565f1
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/FullTextFunctionContributor.java
@@ -0,0 +1,20 @@
+package codezap.template.repository;
+
+import static org.hibernate.type.StandardBasicTypes.BOOLEAN;
+
+import org.hibernate.boot.model.FunctionContributions;
+import org.hibernate.boot.model.FunctionContributor;
+
+public class FullTextFunctionContributor implements FunctionContributor {
+
+    private static final String FUNCTION_NAME = "fulltext_match";
+    private static final String MATCH_AGAINST_FUNCTION = "match(?1, ?2) against(?3)";
+
+    @Override
+    public void contributeFunctions(FunctionContributions functionContributions) {
+        functionContributions
+                .getFunctionRegistry()
+                .registerPattern(FUNCTION_NAME, MATCH_AGAINST_FUNCTION,
+                        functionContributions.getTypeConfiguration().getBasicTypeRegistry().resolve(BOOLEAN));
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/FullTextSearchMySQLDialect.java b/backend/src/main/java/codezap/template/repository/FullTextSearchMySQLDialect.java
index 49bcd931f..0e200d0a7 100644
--- a/backend/src/main/java/codezap/template/repository/FullTextSearchMySQLDialect.java
+++ b/backend/src/main/java/codezap/template/repository/FullTextSearchMySQLDialect.java
@@ -11,41 +11,41 @@
 import org.hibernate.sql.ast.SqlAstNodeRenderingMode;
 import org.hibernate.sql.ast.SqlAstTranslator;
 import org.hibernate.sql.ast.spi.SqlAppender;
-import org.hibernate.sql.ast.tree.SqlAstNode;
-
-public class FullTextSearchMySQLDialect extends MySQLDialect {
-
-    @Override
-    public void initializeFunctionRegistry(FunctionContributions functionContributions) {
-        super.initializeFunctionRegistry(functionContributions);
-
-        SqmFunctionRegistry functionRegistry = functionContributions.getFunctionRegistry();
-        functionRegistry.register("match", ExactPhraseMatchFunction.INSTANCE);
-    }
-
-    public static class ExactPhraseMatchFunction extends NamedSqmFunctionDescriptor {
-
-        public static final ExactPhraseMatchFunction INSTANCE = new ExactPhraseMatchFunction();
-
-        public ExactPhraseMatchFunction() {
-            super("MATCH", false, StandardArgumentsValidators.exactly(3), null);
-        }
-
-        @Override
-        public void render(
-                SqlAppender sqlAppender,
-                List<? extends SqlAstNode> arguments,
-                ReturnableType<?> returnType,
-                SqlAstTranslator<?> translator
-        ) {
-            sqlAppender.appendSql("MATCH(");
-            translator.render(arguments.get(0), SqlAstNodeRenderingMode.DEFAULT);
-            sqlAppender.appendSql(", ");
-            translator.render(arguments.get(1), SqlAstNodeRenderingMode.DEFAULT);
-            sqlAppender.appendSql(") AGAINST (");
-            translator.render(arguments.get(2), SqlAstNodeRenderingMode.DEFAULT);
-            sqlAppender.appendSql(" IN NATURAL LANGUAGE MODE)");
-
-        }
-    }
-}
+import org.hibernate.sql.ast.tree.SqlAstNode;	
+
+public class FullTextSearchMySQLDialect extends MySQLDialect {	
+
+    @Override	
+    public void initializeFunctionRegistry(FunctionContributions functionContributions) {	
+        super.initializeFunctionRegistry(functionContributions);	
+
+        SqmFunctionRegistry functionRegistry = functionContributions.getFunctionRegistry();	
+        functionRegistry.register("match", ExactPhraseMatchFunction.INSTANCE);	
+    }	
+
+    public static class ExactPhraseMatchFunction extends NamedSqmFunctionDescriptor {	
+
+        public static final ExactPhraseMatchFunction INSTANCE = new ExactPhraseMatchFunction();	
+
+        public ExactPhraseMatchFunction() {	
+            super("MATCH", false, StandardArgumentsValidators.exactly(3), null);	
+        }	
+
+        @Override	
+        public void render(	
+                SqlAppender sqlAppender,	
+                List<? extends SqlAstNode> arguments,	
+                ReturnableType<?> returnType,	
+                SqlAstTranslator<?> translator	
+        ) {	
+            sqlAppender.appendSql("MATCH(");	
+            translator.render(arguments.get(0), SqlAstNodeRenderingMode.DEFAULT);	
+            sqlAppender.appendSql(", ");	
+            translator.render(arguments.get(1), SqlAstNodeRenderingMode.DEFAULT);	
+            sqlAppender.appendSql(") AGAINST (");	
+            translator.render(arguments.get(2), SqlAstNodeRenderingMode.DEFAULT);	
+            sqlAppender.appendSql(" IN NATURAL LANGUAGE MODE)");	
+
+        }	
+    }	
+}	
diff --git a/backend/src/main/java/codezap/template/repository/SourceCodeJpaRepository.java b/backend/src/main/java/codezap/template/repository/SourceCodeJpaRepository.java
index bb9e5833e..6523894f3 100644
--- a/backend/src/main/java/codezap/template/repository/SourceCodeJpaRepository.java
+++ b/backend/src/main/java/codezap/template/repository/SourceCodeJpaRepository.java
@@ -4,39 +4,17 @@
 import java.util.Optional;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Modifying;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
-import codezap.global.exception.CodeZapException;
-import codezap.global.exception.ErrorCode;
 import codezap.template.domain.SourceCode;
 import codezap.template.domain.Template;
 
-@SuppressWarnings("unused")
-public interface SourceCodeJpaRepository extends SourceCodeRepository, JpaRepository<SourceCode, Long> {
-
-    default SourceCode fetchById(Long id) {
-        return findById(id).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 소스 코드가 존재하지 않습니다."));
-    }
+public interface SourceCodeJpaRepository extends JpaRepository<SourceCode, Long> {
 
     List<SourceCode> findAllByTemplate(Template template);
 
-    default SourceCode fetchByTemplateAndOrdinal(Template template, int ordinal) {
-        return findByTemplateAndOrdinal(template, ordinal)
-                .orElseThrow(
-                        () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND,
-                                "템플릿에 " + ordinal + "번째 소스 코드가 존재하지 않습니다."));
-    }
-
     Optional<SourceCode> findByTemplateAndOrdinal(Template template, int ordinal);
 
     List<SourceCode> findAllByTemplateAndOrdinal(Template template, int ordinal);
 
     int countByTemplate(Template template);
-
-    @Modifying(clearAutomatically = true)
-    @Query("DELETE FROM SourceCode s WHERE s.template.id in :templateIds")
-    void deleteAllByTemplateIds(@Param("templateIds") List<Long> templateIds);
 }
diff --git a/backend/src/main/java/codezap/template/repository/SourceCodeQueryDSLRepository.java b/backend/src/main/java/codezap/template/repository/SourceCodeQueryDSLRepository.java
new file mode 100644
index 000000000..aed69961b
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/SourceCodeQueryDSLRepository.java
@@ -0,0 +1,25 @@
+package codezap.template.repository;
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.template.domain.QSourceCode;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class SourceCodeQueryDSLRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Modifying(clearAutomatically = true)
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        queryFactory.delete(QSourceCode.sourceCode)
+                .where(QSourceCode.sourceCode.template.id.in(templateIds))
+                .execute();
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/SourceCodeRepository.java b/backend/src/main/java/codezap/template/repository/SourceCodeRepository.java
index a605d7348..33bcf8034 100644
--- a/backend/src/main/java/codezap/template/repository/SourceCodeRepository.java
+++ b/backend/src/main/java/codezap/template/repository/SourceCodeRepository.java
@@ -1,30 +1,57 @@
 package codezap.template.repository;
 
 import java.util.List;
-import java.util.Optional;
 
+import org.springframework.stereotype.Repository;
+
+import codezap.global.exception.CodeZapException;
+import codezap.global.exception.ErrorCode;
 import codezap.template.domain.SourceCode;
 import codezap.template.domain.Template;
+import lombok.RequiredArgsConstructor;
 
-public interface SourceCodeRepository {
+@Repository
+@RequiredArgsConstructor
+public class SourceCodeRepository {
 
-    SourceCode fetchById(Long id);
+    private final SourceCodeJpaRepository sourceCodeJpaRepository;
+    private final SourceCodeQueryDSLRepository sourceCodeQueryDSLRepository;
 
-    List<SourceCode> findAllByTemplate(Template template);
+    public SourceCode fetchById(Long id) {
+        return sourceCodeJpaRepository.findById(id).orElseThrow(
+                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 소스 코드가 존재하지 않습니다."));
+    }
 
-    SourceCode fetchByTemplateAndOrdinal(Template template, int ordinal);
+    public SourceCode fetchByTemplateAndOrdinal(Template template, int ordinal) {
+        return sourceCodeJpaRepository.findByTemplateAndOrdinal(template, ordinal)
+                .orElseThrow(() -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "템플릿에 " + ordinal + "번째 소스 코드가 존재하지 않습니다."));
+    }
 
-    Optional<SourceCode> findByTemplateAndOrdinal(Template template, int ordinal);
+    public List<SourceCode> findAllByTemplate(Template template) {
+        return sourceCodeJpaRepository.findAllByTemplate(template);
+    }
 
-    List<SourceCode> findAllByTemplateAndOrdinal(Template template, int ordinal);
+    public List<SourceCode> findAllByTemplateAndOrdinal(Template template, int ordinal) {
+        return sourceCodeJpaRepository.findAllByTemplateAndOrdinal(template, ordinal);
+    }
 
-    int countByTemplate(Template template);
+    public int countByTemplate(Template template) {
+        return sourceCodeJpaRepository.countByTemplate(template);
+    }
 
-    SourceCode save(SourceCode sourceCode);
+    public SourceCode save(SourceCode sourceCode) {
+        return sourceCodeJpaRepository.save(sourceCode);
+    }
 
-    <S extends SourceCode> List<S> saveAll(Iterable<S> entities);
+    public List<SourceCode> saveAll(Iterable<SourceCode> entities) {
+        return sourceCodeJpaRepository.saveAll(entities);
+    }
 
-    void deleteById(Long id);
+    public void deleteById(Long id) {
+        sourceCodeJpaRepository.deleteById(id);
+    }
 
-    void deleteAllByTemplateIds(List<Long> templateIds);
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        sourceCodeQueryDSLRepository.deleteAllByTemplateIds(templateIds);
+    }
 }
diff --git a/backend/src/main/java/codezap/template/repository/TemplateJpaRepository.java b/backend/src/main/java/codezap/template/repository/TemplateJpaRepository.java
index ee85472b0..d787d1fa2 100644
--- a/backend/src/main/java/codezap/template/repository/TemplateJpaRepository.java
+++ b/backend/src/main/java/codezap/template/repository/TemplateJpaRepository.java
@@ -2,28 +2,13 @@
 
 import java.util.List;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.domain.Specification;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 
-import codezap.global.exception.CodeZapException;
-import codezap.global.exception.ErrorCode;
 import codezap.template.domain.Template;
 
-@SuppressWarnings("unused")
-public interface TemplateJpaRepository extends TemplateRepository, JpaRepository<Template, Long>,
-        JpaSpecificationExecutor<Template> {
-
-    default Template fetchById(Long id) {
-        return findById(id).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 템플릿이 존재하지 않습니다."));
-    }
+public interface TemplateJpaRepository extends JpaRepository<Template, Long> {
 
     List<Template> findByMemberId(Long id);
 
-    Page<Template> findAll(Specification<Template> specification, Pageable pageable);
-
     boolean existsByCategoryId(Long categoryId);
 }
diff --git a/backend/src/main/java/codezap/template/repository/TemplateOrderSpecifierUtils.java b/backend/src/main/java/codezap/template/repository/TemplateOrderSpecifierUtils.java
new file mode 100644
index 000000000..24b884154
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/TemplateOrderSpecifierUtils.java
@@ -0,0 +1,56 @@
+package codezap.template.repository;
+
+import static codezap.template.domain.QTemplate.template;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.data.domain.Sort;
+
+import com.querydsl.core.types.Order;
+import com.querydsl.core.types.OrderSpecifier;
+import com.querydsl.core.types.Path;
+import com.querydsl.core.types.dsl.PathBuilder;
+
+import codezap.template.domain.Template;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class TemplateOrderSpecifierUtils {
+
+    private static final String TEMPLATE = "template";
+    private static final PathBuilder<Template> TEMPLATE_PATH = new PathBuilder<>(Template.class, TEMPLATE);
+    private static final Map<String, Path<?>> ORDER_FIELDS = Map.of(
+            "likesCount", template.likesCount,
+            "createdAt", template.createdAt,
+            "modifiedAt", template.modifiedAt
+    );
+
+    public static OrderSpecifier<?>[] getOrderSpecifier(Sort sort) {
+        List<OrderSpecifier<?>> orders = new ArrayList<>();
+        sort.forEach(order -> addOrder(order, orders));
+
+        return orders.toArray(new OrderSpecifier[0]);
+    }
+
+    private static void addOrder(Sort.Order order, List<OrderSpecifier<?>> orders) {
+        Order direction = getOrder(order);
+        orders.add(createOrderSpecifier(order.getProperty(), direction));
+    }
+
+    private static Order getOrder(Sort.Order order) {
+        if (order.isAscending()) {
+            return Order.ASC;
+        }
+        return Order.DESC;
+    }
+
+    private static OrderSpecifier createOrderSpecifier(String property, Order direction) {
+        if (ORDER_FIELDS.containsKey(property)) {
+            return new OrderSpecifier(direction, ORDER_FIELDS.get(property));
+        }
+        return new OrderSpecifier(direction, TEMPLATE_PATH.get(property));
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java b/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java
new file mode 100644
index 000000000..e073b11c5
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java
@@ -0,0 +1,89 @@
+package codezap.template.repository;
+
+import static codezap.template.domain.QTemplate.template;
+
+import java.util.List;
+import java.util.Objects;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.template.domain.Template;
+import codezap.template.domain.Visibility;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class TemplateQueryDSLRepository {
+
+    private final JPAQueryFactory queryFactory;
+    private final TemplateSearchExpressionProvider expressionProvider;
+
+    public Page<Template> findTemplates(
+            Long memberId,
+            String keyword,
+            Long categoryId,
+            List<Long> tagIds,
+            Visibility visibility,
+            Pageable pageable
+    ) {
+        List<Template> content = getTemplates(memberId, keyword, categoryId, tagIds, visibility, pageable);
+        long count = count(memberId, keyword, categoryId, tagIds, visibility);
+        return new PageImpl<>(content, pageable, count);
+    }
+
+    private List<Template> getTemplates(
+            Long memberId,
+            String keyword,
+            Long categoryId,
+            List<Long> tagIds,
+            Visibility visibility,
+            Pageable pageable
+    ) {
+        return queryFactory
+                .selectFrom(template)
+                .leftJoin(template.category).fetchJoin()
+                .leftJoin(template.member).fetchJoin()
+                .where(matchesKeyword(memberId, keyword, categoryId, tagIds, visibility))
+                .orderBy(TemplateOrderSpecifierUtils.getOrderSpecifier(pageable.getSort()))
+                .offset(pageable.getOffset())
+                .limit(pageable.getPageSize())
+                .fetch();
+    }
+
+    private long count(
+            Long memberId,
+            String keyword,
+            Long categoryId,
+            List<Long> tagIds,
+            Visibility visibility
+    ) {
+        return Objects.requireNonNull(queryFactory
+                .select(template.count())
+                .from(template)
+                .where(matchesKeyword(memberId, keyword, categoryId, tagIds, visibility))
+                .fetchOne());
+    }
+
+    private BooleanExpression[] matchesKeyword(
+            Long memberId,
+            String keyword,
+            Long categoryId,
+            List<Long> tagIds,
+            Visibility visibility
+    ) {
+        return new BooleanExpression[]{
+                expressionProvider.filterMember(memberId),
+                expressionProvider.filterCategory(categoryId),
+                expressionProvider.filterVisibility(visibility),
+                expressionProvider.hasAnyTags(tagIds),
+                expressionProvider.matchesKeyword(keyword)
+        };
+    }
+}
+
diff --git a/backend/src/main/java/codezap/template/repository/TemplateRepository.java b/backend/src/main/java/codezap/template/repository/TemplateRepository.java
index 81c4b771b..f17f2a1fb 100644
--- a/backend/src/main/java/codezap/template/repository/TemplateRepository.java
+++ b/backend/src/main/java/codezap/template/repository/TemplateRepository.java
@@ -4,21 +4,45 @@
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Repository;
 
+import codezap.global.exception.CodeZapException;
+import codezap.global.exception.ErrorCode;
 import codezap.template.domain.Template;
-
-public interface TemplateRepository {
-
-    Template fetchById(Long id);
-
-    List<Template> findByMemberId(Long id);
-
-    Page<Template> findAll(Specification<Template> specification, Pageable pageable);
-
-    boolean existsByCategoryId(Long categoryId);
-
-    Template save(Template template);
-
-    void deleteById(Long id);
+import codezap.template.domain.Visibility;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class TemplateRepository {
+
+    private final TemplateJpaRepository templateJpaRepository;
+    private final TemplateQueryDSLRepository templateQueryDSLRepository;
+
+    public Template fetchById(Long id) {
+        return templateJpaRepository.findById(id).orElseThrow(
+                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자 " + id + "에 해당하는 템플릿이 존재하지 않습니다."));
+    }
+
+    public List<Template> findByMemberId(Long id) {
+        return templateJpaRepository.findByMemberId(id);
+    }
+
+    public Page<Template> findAll(
+            Long memberId, String keyword, Long categoryId, List<Long> tagIds, Visibility visibility, Pageable pageable
+    ) {
+        return templateQueryDSLRepository.findTemplates(memberId, keyword, categoryId, tagIds, visibility, pageable);
+    }
+
+    public boolean existsByCategoryId(Long categoryId) {
+        return templateJpaRepository.existsByCategoryId(categoryId);
+    }
+
+    public Template save(Template template) {
+        return templateJpaRepository.save(template);
+    }
+
+    public void deleteById(Long id) {
+        templateJpaRepository.deleteById(id);
+    }
 }
diff --git a/backend/src/main/java/codezap/template/repository/TemplateSearchExpressionProvider.java b/backend/src/main/java/codezap/template/repository/TemplateSearchExpressionProvider.java
new file mode 100644
index 000000000..0982f3459
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/TemplateSearchExpressionProvider.java
@@ -0,0 +1,74 @@
+package codezap.template.repository;
+
+import static codezap.template.domain.QTemplate.template;
+import static codezap.template.domain.QTemplateTag.templateTag;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.springframework.stereotype.Component;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.jpa.JPAExpressions;
+
+import codezap.template.domain.Visibility;
+import codezap.template.repository.strategy.FullTextSearchSearchStrategy;
+import codezap.template.repository.strategy.LikeSearchStrategy;
+import lombok.RequiredArgsConstructor;
+
+@Component
+@RequiredArgsConstructor
+public class TemplateSearchExpressionProvider {
+
+    private final LikeSearchStrategy likeSearchStrategy;
+    private final FullTextSearchSearchStrategy fullTextSearchStrategy;
+
+    private static final int MINIMUM_KEYWORD_LENGTH = 3;
+
+    public BooleanExpression filterMember(Long memberId) {
+        return Optional.ofNullable(memberId)
+                .map(template.member.id::eq)
+                .orElse(null);
+    }
+
+    public BooleanExpression filterCategory(Long categoryId) {
+        return Optional.ofNullable(categoryId)
+                .map(template.category.id::eq)
+                .orElse(null);
+    }
+
+    public BooleanExpression filterVisibility(Visibility visibility) {
+        return Optional.ofNullable(visibility)
+                .map(template.visibility::eq)
+                .orElse(null);
+    }
+
+    public BooleanExpression hasAnyTags(List<Long> tagIds) {
+        if (tagIds == null || tagIds.isEmpty()) {
+            return null;
+        }
+
+        return template.id.in(
+                JPAExpressions
+                        .select(templateTag.template.id)
+                        .from(templateTag)
+                        .where(templateTag.tag.id.in(tagIds))
+        );
+    }
+
+    public BooleanExpression matchesKeyword(String keyword) {
+        return Optional.ofNullable(keyword)
+                .filter(k -> !k.isBlank())
+                .map(String::trim)
+                .map(this::createKeywordMatchExpression)
+                .orElse(null);
+    }
+
+    private BooleanExpression createKeywordMatchExpression(String trimmedKeyword) {
+        if (trimmedKeyword.length() < MINIMUM_KEYWORD_LENGTH) {
+            return likeSearchStrategy.matchedKeyword(trimmedKeyword);
+        }
+
+        return fullTextSearchStrategy.matchedKeyword(trimmedKeyword);
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/TemplateSpecification.java b/backend/src/main/java/codezap/template/repository/TemplateSpecification.java
deleted file mode 100644
index e4fa9a6d9..000000000
--- a/backend/src/main/java/codezap/template/repository/TemplateSpecification.java
+++ /dev/null
@@ -1,119 +0,0 @@
-package codezap.template.repository;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import jakarta.persistence.criteria.CriteriaBuilder;
-import jakarta.persistence.criteria.CriteriaQuery;
-import jakarta.persistence.criteria.JoinType;
-import jakarta.persistence.criteria.Predicate;
-import jakarta.persistence.criteria.Root;
-import jakarta.persistence.criteria.Subquery;
-
-import org.springframework.data.jpa.domain.Specification;
-
-import codezap.template.domain.SourceCode;
-import codezap.template.domain.Template;
-import codezap.template.domain.TemplateTag;
-import codezap.template.domain.Visibility;
-
-public class TemplateSpecification implements Specification<Template> {
-
-    private final Long memberId;
-    private final String keyword;
-    private final Long categoryId;
-    private final List<Long> tagIds;
-    private final Visibility visibility;
-
-    public TemplateSpecification(
-            Long memberId,
-            String keyword,
-            Long categoryId,
-            List<Long> tagIds,
-            Visibility visibility
-    ) {
-        this.memberId = memberId;
-        this.keyword = keyword;
-        this.categoryId = categoryId;
-        this.tagIds = tagIds;
-        this.visibility = visibility;
-    }
-
-    @Override
-    public Predicate toPredicate(Root<Template> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
-        List<Predicate> predicates = new ArrayList<>();
-
-        addMemberPredicate(predicates, criteriaBuilder, root);
-        addCategoryPredicate(predicates, criteriaBuilder, root);
-        addTagPredicate(predicates, criteriaBuilder, root, query);
-        addKeywordPredicate(predicates, criteriaBuilder, root, query);
-        addVisibility(predicates, criteriaBuilder, root, query);
-
-        if (query.getResultType().equals(Template.class)) {
-            root.fetch("category", JoinType.LEFT);
-            root.fetch("member", JoinType.LEFT);
-        }
-
-        return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
-    }
-
-    private void addMemberPredicate(List<Predicate> predicates, CriteriaBuilder criteriaBuilder, Root<Template> root) {
-        if (memberId != null) {
-            predicates.add(criteriaBuilder.equal(root.get("member").get("id"), memberId));
-        }
-    }
-
-    private void addKeywordPredicate(List<Predicate> predicates, CriteriaBuilder criteriaBuilder, Root<Template> root,
-            CriteriaQuery<?> query
-    ) {
-        if (keyword != null && !keyword.trim().isEmpty()) {
-            String searchKeyword = keyword.trim();
-
-            Predicate titleDescriptionPredicate = criteriaBuilder.isTrue(
-                    criteriaBuilder.function("MATCH", Boolean.class,
-                            root.get("title"),
-                            root.get("description"),
-                            criteriaBuilder.literal(searchKeyword)));
-
-            Subquery<Long> sourceCodeSubquery = query.subquery(Long.class);
-            Root<SourceCode> sourceCodeRoot = sourceCodeSubquery.from(SourceCode.class);
-            sourceCodeSubquery.select(sourceCodeRoot.get("template").get("id"));
-            sourceCodeSubquery.where(criteriaBuilder.isTrue(
-                    criteriaBuilder.function("MATCH", Boolean.class,
-                            sourceCodeRoot.get("content"),
-                            sourceCodeRoot.get("filename"),
-                            criteriaBuilder.literal(searchKeyword))));
-
-            predicates.add(criteriaBuilder.or(titleDescriptionPredicate, root.get("id").in(sourceCodeSubquery)));
-        }
-    }
-
-    private void addCategoryPredicate(List<Predicate> predicates, CriteriaBuilder criteriaBuilder, Root<Template> root
-    ) {
-        if (categoryId != null) {
-            predicates.add(criteriaBuilder.equal(root.get("category").get("id"), categoryId));
-        }
-    }
-
-    private void addTagPredicate(
-            List<Predicate> predicates, CriteriaBuilder criteriaBuilder, Root<Template> root, CriteriaQuery<?> query
-    ) {
-        if (tagIds == null || tagIds.isEmpty()) {
-            return;
-        }
-        Subquery<Long> subquery = query.subquery(Long.class);
-        Root<TemplateTag> subRoot = subquery.from(TemplateTag.class);
-        subquery.select(subRoot.get("template").get("id"))
-                .where(subRoot.get("tag").get("id").in(tagIds));
-
-        predicates.add(root.get("id").in(subquery));
-    }
-
-    private void addVisibility(
-            List<Predicate> predicates, CriteriaBuilder criteriaBuilder, Root<Template> root, CriteriaQuery<?> query
-    ) {
-        if (visibility != null) {
-            predicates.add(criteriaBuilder.equal(root.get("visibility"), visibility));
-        }
-    }
-}
diff --git a/backend/src/main/java/codezap/template/repository/ThumbnailJpaRepository.java b/backend/src/main/java/codezap/template/repository/ThumbnailJpaRepository.java
index e0bd5e140..681c1eb6a 100644
--- a/backend/src/main/java/codezap/template/repository/ThumbnailJpaRepository.java
+++ b/backend/src/main/java/codezap/template/repository/ThumbnailJpaRepository.java
@@ -1,49 +1,10 @@
 package codezap.template.repository;
 
-import java.util.List;
-import java.util.Optional;
-
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Modifying;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
-import codezap.global.exception.CodeZapException;
-import codezap.global.exception.ErrorCode;
-import codezap.template.domain.Template;
 import codezap.template.domain.Thumbnail;
 
-@SuppressWarnings("unused")
-public interface ThumbnailJpaRepository extends
-        ThumbnailRepository, JpaRepository<Thumbnail, Long> {
-
-    default Thumbnail fetchByTemplate(Template template) {
-        return findByTemplate(template).orElseThrow(
-                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND,
-                        "식별자가 " + template.getId() + "인 템플릿에 해당하는 썸네일이 없습니다."));
-    }
-
-    @Query("""
-            SELECT t, sc
-            FROM Thumbnail t
-            join fetch t.sourceCode sc
-            WHERE t.template = :template
-            """)
-    Optional<Thumbnail> findByTemplate(@Param("template") Template template);
-
-
-    @Modifying(clearAutomatically = true)
-    @Query("DELETE FROM Thumbnail t WHERE t.template.id in :templateIds")
-    void deleteAllByTemplateIds(@Param("templateIds") List<Long> templateIds);
-
-    @Query("""
-            SELECT t, sc
-            FROM Thumbnail t
-            join fetch t.sourceCode sc
-            WHERE t.template.id IN :templateIds
-            """)
-    List<Thumbnail> findAllByTemplateIn(@Param("templateIds") List<Long> templateIds);
+public interface ThumbnailJpaRepository extends JpaRepository<Thumbnail, Long> {
 
     void deleteByTemplateId(Long id);
-
 }
diff --git a/backend/src/main/java/codezap/template/repository/ThumbnailQueryDSLRepository.java b/backend/src/main/java/codezap/template/repository/ThumbnailQueryDSLRepository.java
new file mode 100644
index 000000000..78c073491
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/ThumbnailQueryDSLRepository.java
@@ -0,0 +1,42 @@
+package codezap.template.repository;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.stereotype.Repository;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.template.domain.QThumbnail;
+import codezap.template.domain.Template;
+import codezap.template.domain.Thumbnail;
+import lombok.RequiredArgsConstructor;
+
+@Repository
+@RequiredArgsConstructor
+public class ThumbnailQueryDSLRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    public Optional<Thumbnail> findByTemplate(Template template) {
+        return Optional.ofNullable(queryFactory.selectFrom(QThumbnail.thumbnail)
+                .innerJoin(QThumbnail.thumbnail.sourceCode).fetchJoin()
+                .where(QThumbnail.thumbnail.template.eq(template))
+                .fetchOne());
+    }
+
+    @Modifying(clearAutomatically = true)
+    public void deleteAllByTemplateIds(List<Long> templateIds) {
+        queryFactory.delete(QThumbnail.thumbnail)
+                .where(QThumbnail.thumbnail.template.id.in(templateIds))
+                .execute();
+    }
+
+    public List<Thumbnail> findAllByTemplateIn(List<Long> templateIds) {
+        return queryFactory.selectFrom(QThumbnail.thumbnail)
+                .innerJoin(QThumbnail.thumbnail.sourceCode).fetchJoin()
+                .where(QThumbnail.thumbnail.template.id.in(templateIds))
+                .fetch();
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/ThumbnailRepository.java b/backend/src/main/java/codezap/template/repository/ThumbnailRepository.java
index e3d6da634..80b114862 100644
--- a/backend/src/main/java/codezap/template/repository/ThumbnailRepository.java
+++ b/backend/src/main/java/codezap/template/repository/ThumbnailRepository.java
@@ -3,20 +3,39 @@
 import java.util.List;
 import java.util.Optional;
 
+import org.springframework.stereotype.Repository;
+
+import codezap.global.exception.CodeZapException;
+import codezap.global.exception.ErrorCode;
 import codezap.template.domain.Template;
 import codezap.template.domain.Thumbnail;
+import lombok.RequiredArgsConstructor;
 
-public interface ThumbnailRepository {
+@Repository
+@RequiredArgsConstructor
+public class ThumbnailRepository {
 
-    Thumbnail fetchByTemplate(Template template);
+    private final ThumbnailJpaRepository thumbnailJpaRepository;
+    private final ThumbnailQueryDSLRepository thumbnailQueryDSLRepository;
 
-    Optional<Thumbnail> findByTemplate(Template template);
+    public Thumbnail fetchByTemplate(Template template) {
+        return thumbnailQueryDSLRepository.findByTemplate(template).orElseThrow(
+                () -> new CodeZapException(ErrorCode.RESOURCE_NOT_FOUND, "식별자가 " + template.getId() + "인 템플릿에 해당하는 썸네일이 없습니다."));
+    }
 
-    List<Thumbnail> findAll();
+    public List<Thumbnail> findAll() {
+        return thumbnailJpaRepository.findAll();
+    }
 
-    List<Thumbnail> findAllByTemplateIn(List<Long> templateIds);
+    public List<Thumbnail> findAllByTemplateIn(List<Long> templateIds) {
+        return thumbnailQueryDSLRepository.findAllByTemplateIn(templateIds);
+    }
 
-    Thumbnail save(Thumbnail thumbnail);
+    public Thumbnail save(Thumbnail thumbnail) {
+        return thumbnailJpaRepository.save(thumbnail);
+    }
 
-    void deleteAllByTemplateIds(List<Long> ids);
+    public void deleteAllByTemplateIds(List<Long> ids) {
+        thumbnailQueryDSLRepository.deleteAllByTemplateIds(ids);
+    }
 }
diff --git a/backend/src/main/java/codezap/template/repository/strategy/FullTextSearchSearchStrategy.java b/backend/src/main/java/codezap/template/repository/strategy/FullTextSearchSearchStrategy.java
new file mode 100644
index 000000000..231cbd59b
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/strategy/FullTextSearchSearchStrategy.java
@@ -0,0 +1,43 @@
+package codezap.template.repository.strategy;
+
+import static codezap.template.domain.QSourceCode.sourceCode;
+import static codezap.template.domain.QTemplate.template;
+
+import org.springframework.stereotype.Component;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.core.types.dsl.Expressions;
+import com.querydsl.core.types.dsl.NumberExpression;
+import com.querydsl.jpa.JPAExpressions;
+
+@Component
+public class FullTextSearchSearchStrategy implements SearchStrategy {
+
+    private static final String MATCH_FUNCTION = "function('fulltext_match', {0}, {1}, {2})";
+    private static final int FULL_TEXT_FIELD_FIRST_ORDER = 0;
+    private static final int FULL_TEXT_FIELD_SECOND_ORDER = 1;
+    private static final int FULL_TEXT_KEYWORD_ORDER = 2;
+    private static final int NO_MATCHED_SCORE = 0;
+
+    @Override
+    public BooleanExpression matchedKeyword(String trimmedKeyword) {
+        NumberExpression<Double> titleScore = getMatchedAccuracy(template.title, template.description, trimmedKeyword);
+        NumberExpression<Double> sourceCodeScore = getMatchedAccuracy(sourceCode.filename, sourceCode.content, trimmedKeyword);
+        return titleScore.gt(NO_MATCHED_SCORE).or(
+                template.id.in(JPAExpressions
+                        .select(sourceCode.template.id)
+                        .from(sourceCode)
+                        .where(sourceCodeScore.gt(NO_MATCHED_SCORE))
+                )
+        );
+    }
+
+    private NumberExpression<Double> getMatchedAccuracy(Object... args) {
+        return Expressions.numberTemplate(Double.class,
+                MATCH_FUNCTION,
+                args[FULL_TEXT_FIELD_FIRST_ORDER],
+                args[FULL_TEXT_FIELD_SECOND_ORDER],
+                args[FULL_TEXT_KEYWORD_ORDER]
+        );
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/strategy/LikeSearchStrategy.java b/backend/src/main/java/codezap/template/repository/strategy/LikeSearchStrategy.java
new file mode 100644
index 000000000..7416d1764
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/strategy/LikeSearchStrategy.java
@@ -0,0 +1,42 @@
+package codezap.template.repository.strategy;
+
+import static codezap.template.domain.QSourceCode.sourceCode;
+import static codezap.template.domain.QTemplate.template;
+
+import org.springframework.stereotype.Component;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.jpa.JPAExpressions;
+
+@Component
+public class LikeSearchStrategy implements SearchStrategy {
+
+    private static final String WILD_CARD = "%";
+
+    @Override
+    public BooleanExpression matchedKeyword(String trimmedKeyword) {
+        String likeSearchedKeyword = WILD_CARD + trimmedKeyword + WILD_CARD;
+
+        return createTitleMatch(likeSearchedKeyword)
+                .or(createDescriptionMatch(likeSearchedKeyword))
+                .or(createSourceCodeMatch(likeSearchedKeyword));
+    }
+
+    private BooleanExpression createTitleMatch(String keyword) {
+        return template.title.likeIgnoreCase(keyword);
+    }
+
+    private BooleanExpression createDescriptionMatch(String keyword) {
+        return template.description.likeIgnoreCase(keyword);
+    }
+
+    private BooleanExpression createSourceCodeMatch(String keyword) {
+        return template.id.in(
+                JPAExpressions
+                        .select(sourceCode.template.id)
+                        .from(sourceCode)
+                        .where(sourceCode.content.likeIgnoreCase(keyword)
+                                .or(sourceCode.filename.likeIgnoreCase(keyword)))
+        );
+    }
+}
diff --git a/backend/src/main/java/codezap/template/repository/strategy/SearchStrategy.java b/backend/src/main/java/codezap/template/repository/strategy/SearchStrategy.java
new file mode 100644
index 000000000..a3e0453fb
--- /dev/null
+++ b/backend/src/main/java/codezap/template/repository/strategy/SearchStrategy.java
@@ -0,0 +1,8 @@
+package codezap.template.repository.strategy;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+
+public interface SearchStrategy {
+
+    BooleanExpression matchedKeyword(String trimmedKeyword);
+}
diff --git a/backend/src/main/java/codezap/template/service/TemplateService.java b/backend/src/main/java/codezap/template/service/TemplateService.java
index ed04667fd..b4d917c26 100644
--- a/backend/src/main/java/codezap/template/service/TemplateService.java
+++ b/backend/src/main/java/codezap/template/service/TemplateService.java
@@ -17,7 +17,6 @@
 import codezap.template.dto.request.CreateTemplateRequest;
 import codezap.template.dto.request.UpdateTemplateRequest;
 import codezap.template.repository.TemplateRepository;
-import codezap.template.repository.TemplateSpecification;
 import lombok.RequiredArgsConstructor;
 
 @Service
@@ -54,8 +53,7 @@ public Page<Template> findAllBy(
             Visibility visibility,
             Pageable pageable
     ) {
-        return templateRepository.findAll(
-                new TemplateSpecification(memberId, keyword, categoryId, tagIds, visibility), pageable);
+        return templateRepository.findAll(memberId, keyword, categoryId, tagIds, visibility, pageable);
     }
 
     @Transactional
diff --git a/backend/src/main/resources/META-INF/services/org.hibernate.boot.model.FunctionContributor b/backend/src/main/resources/META-INF/services/org.hibernate.boot.model.FunctionContributor
new file mode 100644
index 000000000..7583eac0f
--- /dev/null
+++ b/backend/src/main/resources/META-INF/services/org.hibernate.boot.model.FunctionContributor
@@ -0,0 +1 @@
+codezap.template.repository.FullTextFunctionContributor
diff --git a/backend/src/main/resources/application-db.yml b/backend/src/main/resources/application-db.yml
index 0929369db..5c0ea644d 100644
--- a/backend/src/main/resources/application-db.yml
+++ b/backend/src/main/resources/application-db.yml
@@ -25,7 +25,4 @@ spring:
     open-in-view: false
     hibernate:
       ddl-auto: validate
-    properties:
-      hibernate:
-        dialect: codezap.template.repository.FullTextSearchMySQLDialect
   data.web.pageable.one-indexed-parameters: true
diff --git a/backend/src/main/resources/application-local.yml b/backend/src/main/resources/application-local.yml
index fd7fb3971..de74cdc07 100644
--- a/backend/src/main/resources/application-local.yml
+++ b/backend/src/main/resources/application-local.yml
@@ -23,9 +23,6 @@ spring:
     # open-in-view: false
     hibernate:
       ddl-auto: create
-    properties:
-      hibernate:
-        dialect: codezap.template.repository.FullTextSearchMySQLDialect
   data.web.pageable.one-indexed-parameters: true
 
 cors:
diff --git a/backend/src/test/java/codezap/auth/provider/basic/BasicAuthCredentialProviderTest.java b/backend/src/test/java/codezap/auth/provider/basic/BasicAuthCredentialProviderTest.java
index a06b01f09..3c5f71f60 100644
--- a/backend/src/test/java/codezap/auth/provider/basic/BasicAuthCredentialProviderTest.java
+++ b/backend/src/test/java/codezap/auth/provider/basic/BasicAuthCredentialProviderTest.java
@@ -19,7 +19,6 @@
 
 import codezap.global.exception.CodeZapException;
 import codezap.global.exception.ErrorCode;
-import codezap.global.repository.JpaRepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.fixture.MemberFixture;
 import codezap.member.repository.MemberRepository;
diff --git a/backend/src/test/java/codezap/category/repository/CategoryRepositoryTest.java b/backend/src/test/java/codezap/category/repository/CategoryRepositoryTest.java
index 85fd180b4..57981ed25 100644
--- a/backend/src/test/java/codezap/category/repository/CategoryRepositoryTest.java
+++ b/backend/src/test/java/codezap/category/repository/CategoryRepositoryTest.java
@@ -13,11 +13,11 @@
 import codezap.fixture.CategoryFixture;
 import codezap.fixture.MemberFixture;
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 
-@JpaRepositoryTest
+@RepositoryTest
 public class CategoryRepositoryTest {
 
     @Autowired
diff --git a/backend/src/test/java/codezap/global/repository/JpaRepositoryTest.java b/backend/src/test/java/codezap/global/repository/JpaRepositoryTest.java
deleted file mode 100644
index b19273b96..000000000
--- a/backend/src/test/java/codezap/global/repository/JpaRepositoryTest.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package codezap.global.repository;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.context.annotation.Import;
-
-import codezap.global.DatabaseIsolation;
-import codezap.global.auditing.JpaAuditingConfiguration;
-import codezap.global.rds.DataSourceConfig;
-
-@Target({ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@DataJpaTest
-@DatabaseIsolation
-@Import({JpaAuditingConfiguration.class, DataSourceConfig.class})
-@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
-public @interface JpaRepositoryTest {
-}
diff --git a/backend/src/test/java/codezap/global/repository/RepositoryTest.java b/backend/src/test/java/codezap/global/repository/RepositoryTest.java
new file mode 100644
index 000000000..52bfc3238
--- /dev/null
+++ b/backend/src/test/java/codezap/global/repository/RepositoryTest.java
@@ -0,0 +1,35 @@
+package codezap.global.repository;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.FilterType;
+import org.springframework.context.annotation.Import;
+import org.springframework.stereotype.Repository;
+
+import codezap.global.DatabaseIsolation;
+import codezap.global.auditing.JpaAuditingConfiguration;
+import codezap.global.querydsl.QueryDSLConfig;
+import codezap.global.rds.DataSourceConfig;
+import codezap.template.repository.TemplateSearchExpressionProvider;
+import codezap.template.repository.strategy.FullTextSearchSearchStrategy;
+import codezap.template.repository.strategy.LikeSearchStrategy;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@DataJpaTest(includeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Repository.class), useDefaultFilters = false)
+@DatabaseIsolation
+@Import({JpaAuditingConfiguration.class,
+        DataSourceConfig.class,
+        QueryDSLConfig.class,
+        TemplateSearchExpressionProvider.class,
+        LikeSearchStrategy.class,
+        FullTextSearchSearchStrategy.class})
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+public @interface RepositoryTest {
+}
diff --git a/backend/src/test/java/codezap/likes/repository/LikesJpaRepositoryTest.java b/backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java
similarity index 98%
rename from backend/src/test/java/codezap/likes/repository/LikesJpaRepositoryTest.java
rename to backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java
index 6cafed4f7..748de9eac 100644
--- a/backend/src/test/java/codezap/likes/repository/LikesJpaRepositoryTest.java
+++ b/backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java
@@ -18,15 +18,15 @@
 import codezap.fixture.CategoryFixture;
 import codezap.fixture.MemberFixture;
 import codezap.fixture.TemplateFixture;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.likes.domain.Likes;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.template.domain.Template;
 import codezap.template.repository.TemplateRepository;
 
-@JpaRepositoryTest
-class LikesJpaRepositoryTest {
+@RepositoryTest
+class LikesRepositoryTest {
 
     @Autowired
     private LikesRepository likesRepository;
diff --git a/backend/src/test/java/codezap/member/repository/MemberJpaRepositoryTest.java b/backend/src/test/java/codezap/member/repository/MemberRepositoryTest.java
similarity index 97%
rename from backend/src/test/java/codezap/member/repository/MemberJpaRepositoryTest.java
rename to backend/src/test/java/codezap/member/repository/MemberRepositoryTest.java
index 5eb55fade..554ab18db 100644
--- a/backend/src/test/java/codezap/member/repository/MemberJpaRepositoryTest.java
+++ b/backend/src/test/java/codezap/member/repository/MemberRepositoryTest.java
@@ -13,13 +13,13 @@
 import codezap.fixture.CategoryFixture;
 import codezap.fixture.MemberFixture;
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.template.domain.Template;
 import codezap.template.repository.TemplateRepository;
 
-@JpaRepositoryTest
-class MemberJpaRepositoryTest {
+@RepositoryTest
+class MemberRepositoryTest {
 
     @Autowired
     private MemberRepository memberRepository;
diff --git a/backend/src/test/java/codezap/tag/repository/TagJpaRepositoryTest.java b/backend/src/test/java/codezap/tag/repository/TagRepositoryTest.java
similarity index 68%
rename from backend/src/test/java/codezap/tag/repository/TagJpaRepositoryTest.java
rename to backend/src/test/java/codezap/tag/repository/TagRepositoryTest.java
index 15d1bce87..8d4ce74cc 100644
--- a/backend/src/test/java/codezap/tag/repository/TagJpaRepositoryTest.java
+++ b/backend/src/test/java/codezap/tag/repository/TagRepositoryTest.java
@@ -12,11 +12,11 @@
 import org.springframework.beans.factory.annotation.Autowired;
 
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.tag.domain.Tag;
 
-@JpaRepositoryTest
-class TagJpaRepositoryTest {
+@RepositoryTest
+class TagRepositoryTest {
 
     @Autowired
     private TagRepository tagRepository;
@@ -46,44 +46,6 @@ void fetchByIdFailByNotExistsId() {
         }
     }
 
-    @Nested
-    @DisplayName("태그명으로 태그 조회(fetch)")
-    class FetchByName {
-
-        @Test
-        @DisplayName("태그명으로 태그 조회 성공 : 태그명으로 태그를 조회할 수 있다.")
-        void fetchByNameSuccess() {
-            Tag tag = tagRepository.save(new Tag("tag"));
-
-            Tag actual = tagRepository.fetchByName(tag.getName());
-
-            assertThat(actual).isEqualTo(tag);
-        }
-
-        @Test
-        @DisplayName("태그명으로 태그 조회 성공 : 대소문자 구분")
-        void findByNameSuccessCaseSensitive() {
-            Tag lowerCaseTag = tagRepository.save(new Tag("java"));
-            Tag upperCaseTag = tagRepository.save(new Tag("Java"));
-
-            var actual1 = tagRepository.fetchByName("java");
-            var actual2 = tagRepository.fetchByName("Java");
-
-            assertThat(actual1).isEqualTo(lowerCaseTag);
-            assertThat(actual2).isEqualTo(upperCaseTag);
-        }
-
-        @Test
-        @DisplayName("태그명으로 태그 조회 실패 : 존재하지 않는 태그명인 경우 에러가 발생한다.")
-        void fetchByNameFailByNotExistsId() {
-            String notExistTagName = "태그";
-
-            assertThatThrownBy(() -> tagRepository.fetchByName(notExistTagName))
-                    .isInstanceOf(CodeZapException.class)
-                    .hasMessage("이름이 " + notExistTagName + "인 태그는 존재하지 않습니다.");
-        }
-    }
-
     @Nested
     @DisplayName("태그명으로 태그 조회(find)")
     class FindByName {
diff --git a/backend/src/test/java/codezap/tag/repository/TemplateTagJpaRepositoryTest.java b/backend/src/test/java/codezap/tag/repository/TemplateTagRepositoryTest.java
similarity index 98%
rename from backend/src/test/java/codezap/tag/repository/TemplateTagJpaRepositoryTest.java
rename to backend/src/test/java/codezap/tag/repository/TemplateTagRepositoryTest.java
index 618954ff2..2374a2636 100644
--- a/backend/src/test/java/codezap/tag/repository/TemplateTagJpaRepositoryTest.java
+++ b/backend/src/test/java/codezap/tag/repository/TemplateTagRepositoryTest.java
@@ -18,7 +18,7 @@
 import codezap.fixture.CategoryFixture;
 import codezap.fixture.MemberFixture;
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.tag.domain.Tag;
@@ -26,8 +26,8 @@
 import codezap.template.domain.TemplateTag;
 import codezap.template.repository.TemplateRepository;
 
-@JpaRepositoryTest
-class TemplateTagJpaRepositoryTest {
+@RepositoryTest
+class TemplateTagRepositoryTest {
 
     @Autowired
     private TemplateRepository templateRepository;
diff --git a/backend/src/test/java/codezap/template/repository/SourceCodeRepositoryTest.java b/backend/src/test/java/codezap/template/repository/SourceCodeRepositoryTest.java
index c55aac9d6..d468faa71 100644
--- a/backend/src/test/java/codezap/template/repository/SourceCodeRepositoryTest.java
+++ b/backend/src/test/java/codezap/template/repository/SourceCodeRepositoryTest.java
@@ -14,12 +14,12 @@
 import codezap.fixture.CategoryFixture;
 import codezap.fixture.MemberFixture;
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.repository.MemberRepository;
 import codezap.template.domain.SourceCode;
 import codezap.template.domain.Template;
 
-@JpaRepositoryTest
+@RepositoryTest
 public class SourceCodeRepositoryTest {
 
     @Autowired
diff --git a/backend/src/test/java/codezap/template/repository/TemplateJpaRepositoryTest.java b/backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java
similarity index 97%
rename from backend/src/test/java/codezap/template/repository/TemplateJpaRepositoryTest.java
rename to backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java
index 7c1ad5d0c..f4cc03d7d 100644
--- a/backend/src/test/java/codezap/template/repository/TemplateJpaRepositoryTest.java
+++ b/backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java
@@ -15,13 +15,13 @@
 import codezap.fixture.MemberFixture;
 import codezap.fixture.TemplateFixture;
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.template.domain.Template;
 
-@JpaRepositoryTest
-class TemplateJpaRepositoryTest {
+@RepositoryTest
+class TemplateRepositoryTest {
 
     @Autowired
     private TemplateRepository templateRepository;
diff --git a/backend/src/test/java/codezap/template/repository/TemplateSearchJpaRepositoryTest.java b/backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java
similarity index 68%
rename from backend/src/test/java/codezap/template/repository/TemplateSearchJpaRepositoryTest.java
rename to backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java
index 73f0b9a0f..b8f4cd086 100644
--- a/backend/src/test/java/codezap/template/repository/TemplateSearchJpaRepositoryTest.java
+++ b/backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java
@@ -11,29 +11,40 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.FilterType;
 import org.springframework.context.annotation.Import;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
-import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Repository;
 import org.springframework.test.context.jdbc.Sql;
 import org.springframework.test.context.jdbc.Sql.ExecutionPhase;
 
 import codezap.category.domain.Category;
 import codezap.category.repository.CategoryRepository;
 import codezap.global.auditing.JpaAuditingConfiguration;
+import codezap.global.querydsl.QueryDSLConfig;
 import codezap.global.rds.DataSourceConfig;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.tag.domain.Tag;
 import codezap.tag.repository.TagRepository;
 import codezap.template.domain.Template;
 import codezap.template.domain.Visibility;
+import codezap.template.repository.strategy.FullTextSearchSearchStrategy;
+import codezap.template.repository.strategy.LikeSearchStrategy;
 
-@DataJpaTest
-@Import({JpaAuditingConfiguration.class, DataSourceConfig.class})
+@DataJpaTest(includeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Repository.class), useDefaultFilters = false)
+@Import({JpaAuditingConfiguration.class,
+        DataSourceConfig.class,
+        QueryDSLConfig.class,
+        TemplateSearchExpressionProvider.class,
+        LikeSearchStrategy.class,
+        FullTextSearchSearchStrategy.class})
 @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
 @Sql(scripts = "classpath:search.sql", executionPhase = ExecutionPhase.BEFORE_TEST_CLASS)
-class TemplateSearchJpaRepositoryTest {
+class TemplateSearchRepositoryTest {
 
     @Autowired
     private TemplateRepository templateRepository;
@@ -48,8 +59,13 @@ class TemplateSearchJpaRepositoryTest {
     @DisplayName("검색 테스트: 회원 ID로 템플릿 조회 성공")
     void testFindByMemberId() {
         Member member1 = memberRepository.fetchById(1L);
-        Specification<Template> spec = new TemplateSpecification(member1.getId(), null, null, null, null);
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                member1.getId(),
+                null,
+                null,
+                null,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent()).hasSize(2),
@@ -62,8 +78,13 @@ void testFindByMemberId() {
     @DisplayName("검색 테스트: 키워드로 템플릿 조회 성공")
     void testFindByKeyword() {
         String keyword = "Template";
-        Specification<Template> spec = new TemplateSpecification(null, keyword, null, null, null);
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                null,
+                keyword,
+                null,
+                null,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent())
@@ -77,10 +98,13 @@ void testFindByKeyword() {
     @DisplayName("검색 테스트: 카테고리 ID로 템플릿 조회 성공")
     void testFindByCategoryId() {
         Category category1 = categoryRepository.fetchById(1L);
-        Specification<Template> spec = new TemplateSpecification(
-                null, null, category1.getId(), null, null
-        );
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                null,
+                null,
+                category1.getId(),
+                null,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent()).hasSize(2),
@@ -95,8 +119,13 @@ void testFindByTagIds() {
         Tag tag1 = tagRepository.fetchById(1L);
         Tag tag2 = tagRepository.fetchById(2L);
         List<Long> tagIds = Arrays.asList(tag1.getId(), tag2.getId());
-        Specification<Template> spec = new TemplateSpecification(null, null, null, tagIds, null);
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                null,
+                null,
+                null,
+                tagIds,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent())
@@ -113,8 +142,13 @@ void testFindByTagIds() {
     void testFindBySingleTagId() {
         Tag tag2 = tagRepository.fetchById(2L);
         List<Long> tagIds = List.of(tag2.getId());
-        Specification<Template> spec = new TemplateSpecification(null, null, null, tagIds, null);
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                null,
+                null,
+                null,
+                tagIds,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent())
@@ -129,8 +163,13 @@ void testFindBySingleTagId() {
     @Test
     @DisplayName("검색 테스트: 공개 범위로 템플릿 조회 성공")
     void testFindByVisibility() {
-        Specification<Template> spec = new TemplateSpecification(null, null, null, null, Visibility.PRIVATE);
-        Page<Template> actual = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> actual = templateRepository.findAll(
+                null,
+                null,
+                null,
+                null,
+                Visibility.PRIVATE,
+                PageRequest.of(0, 10));
 
         assertThat(actual.getContent()).hasSize(1)
                 .containsExactlyInAnyOrder(templateRepository.fetchById(4L));
@@ -141,10 +180,13 @@ void testFindByVisibility() {
     void testFindByMemberIdAndKeyword() {
         Member member1 = memberRepository.fetchById(1L);
         String keyword = "Template";
-        Specification<Template> spec = new TemplateSpecification(
-                member1.getId(), keyword, null, null, null
-        );
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                member1.getId(),
+                keyword,
+                null,
+                null,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent()).hasSize(2),
@@ -160,10 +202,13 @@ void testFindByMemberIdAndKeyword() {
     void testFindByMemberIdAndCategoryId() {
         Member member1 = memberRepository.fetchById(1L);
         Category category1 = categoryRepository.fetchById(1L);
-        Specification<Template> spec = new TemplateSpecification(
-                member1.getId(), null, category1.getId(), null, null
-        );
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                member1.getId(),
+                null,
+                category1.getId(),
+                null,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent()).hasSize(1),
@@ -179,10 +224,13 @@ void testFindByMemberIdAndTagIds() {
         Tag tag1 = tagRepository.fetchById(1L);
         Tag tag2 = tagRepository.fetchById(2L);
         List<Long> tagIds = Arrays.asList(tag1.getId(), tag2.getId());
-        Specification<Template> spec = new TemplateSpecification(
-                member1.getId(), null, null, tagIds, null
-        );
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                member1.getId(),
+                null,
+                null,
+                tagIds,
+                null,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent()).hasSize(2),
@@ -195,10 +243,13 @@ void testFindByMemberIdAndTagIds() {
     @DisplayName("검색 테스트: 회원 ID와 공개 범위로 템플릿 조회 성공")
     void testFindByMemberIdAndVisibility() {
         Member member1 = memberRepository.fetchById(2L);
-        Specification<Template> spec = new TemplateSpecification(
-                member1.getId(), null, null, null, Visibility.PUBLIC
-        );
-        Page<Template> actual = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> actual = templateRepository.findAll(
+                member1.getId(),
+                null,
+                null,
+                null,
+                Visibility.PUBLIC,
+                PageRequest.of(0, 10));
 
         assertThat(actual.getContent()).hasSize(1)
                 .containsExactlyInAnyOrder(templateRepository.fetchById(3L));
@@ -213,10 +264,13 @@ void testFindWithAllCriteria() {
         Tag tag2 = tagRepository.fetchById(2L);
         String keyword = "Template";
         List<Long> tagIds = Arrays.asList(tag1.getId(), tag2.getId());
-        Specification<Template> spec = new TemplateSpecification(
-                member1.getId(), keyword, category1.getId(), tagIds, Visibility.PUBLIC
-        );
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                member1.getId(),
+                keyword,
+                category1.getId(),
+                tagIds,
+                Visibility.PUBLIC,
+                PageRequest.of(0, 10));
 
         assertAll(
                 () -> assertThat(result.getContent()).hasSize(1),
@@ -227,10 +281,13 @@ void testFindWithAllCriteria() {
     @Test
     @DisplayName("검색 테스트: 검색 결과가 없는 경우 빈 리스트 반환 성공")
     void testFindWithNoResults() {
-        Specification<Template> spec = new TemplateSpecification(
-                null, "없지롱", null, null, null
-        );
-        Page<Template> result = templateRepository.findAll(spec, PageRequest.of(0, 10));
+        Page<Template> result = templateRepository.findAll(
+                null,
+                "없지롱",
+                null,
+                null,
+                null,
+                PageRequest.of(0, 10));
 
         assertThat(result.getContent()).isEmpty();
     }
diff --git a/backend/src/test/java/codezap/template/repository/ThumbnailRepositoryTest.java b/backend/src/test/java/codezap/template/repository/ThumbnailRepositoryTest.java
index 29101c388..b6776bbc5 100644
--- a/backend/src/test/java/codezap/template/repository/ThumbnailRepositoryTest.java
+++ b/backend/src/test/java/codezap/template/repository/ThumbnailRepositoryTest.java
@@ -18,14 +18,14 @@
 import codezap.fixture.SourceCodeFixture;
 import codezap.fixture.TemplateFixture;
 import codezap.global.exception.CodeZapException;
-import codezap.global.repository.JpaRepositoryTest;
+import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.template.domain.SourceCode;
 import codezap.template.domain.Template;
 import codezap.template.domain.Thumbnail;
 
-@JpaRepositoryTest
+@RepositoryTest
 public class ThumbnailRepositoryTest {
 
     @Autowired
diff --git a/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java b/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java
index 217bea4c0..724277779 100644
--- a/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java
+++ b/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java
@@ -19,7 +19,6 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.domain.Specification;
 
 import codezap.category.domain.Category;
 import codezap.fixture.CategoryFixture;
@@ -41,7 +40,6 @@
 import codezap.template.dto.request.UpdateTemplateRequest;
 import codezap.template.dto.response.FindAllTemplateItemResponse;
 import codezap.template.dto.response.FindAllTemplatesResponse;
-import codezap.template.repository.TemplateSpecification;
 
 class TemplateApplicationServiceTest extends ServiceTest {
 
@@ -526,8 +524,7 @@ void deleteByMemberAndIds() {
             sut.deleteAllByMemberAndTemplateIds(member, deleteIds);
 
             // then
-            Specification<Template> spec = new TemplateSpecification(member.getId(), null, null, null, null);
-            var actualTemplatesLeft = templateRepository.findAll(spec, PageRequest.of(0, 10));
+            var actualTemplatesLeft = templateRepository.findAll(member.getId(), null, null, null, null, PageRequest.of(0, 10));
             var actualSourceCodeLeft = sourceCodeRepository.findAllByTemplate(template1);
             actualSourceCodeLeft.addAll(sourceCodeRepository.findAllByTemplate(template2));
             actualSourceCodeLeft.addAll(sourceCodeRepository.findAllByTemplate(template3));

From c4b46b8ca393d2bd345d2f6b449a616fe66a240e Mon Sep 17 00:00:00 2001
From: Moly <102847513+jminkkk@users.noreply.github.com>
Date: Sat, 9 Nov 2024 02:09:49 +0900
Subject: [PATCH 3/8] =?UTF-8?q?=EC=A2=8B=EC=95=84=EC=9A=94=20=EC=BB=AC?=
 =?UTF-8?q?=EB=9F=BC=20=EB=B0=98=EC=A0=95=EA=B7=9C=ED=99=94=20(#893)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../codezap/likes/service/LikesService.java   | 12 ++++--
 .../codezap/template/domain/Template.java     | 19 ++++++++-
 .../V9__like_column_denormalization.sql       |  8 ++++
 .../likes/service/LikesServiceTest.java       | 26 +++++-------
 .../codezap/template/domain/TemplateTest.java | 41 +++++++++++++++++++
 .../template/service/TemplateServiceTest.java | 11 +++--
 6 files changed, 91 insertions(+), 26 deletions(-)
 create mode 100644 backend/src/main/resources/db/migration/V9__like_column_denormalization.sql

diff --git a/backend/src/main/java/codezap/likes/service/LikesService.java b/backend/src/main/java/codezap/likes/service/LikesService.java
index 01f1f08ab..62f6c4e8c 100644
--- a/backend/src/main/java/codezap/likes/service/LikesService.java
+++ b/backend/src/main/java/codezap/likes/service/LikesService.java
@@ -28,11 +28,12 @@ public void like(Member member, long templateId) {
         if (isLiked(member, template)) {
             return;
         }
-        Likes likes = new Likes(null, template, member);
-        likesRepository.save(likes);
+
+        likesRepository.save(new Likes(template, member));
+        template.increaseLike();
     }
 
-    public Boolean isLiked(Member member, Template template) {
+    public boolean isLiked(Member member, Template template) {
         return likesRepository.existsByMemberAndTemplate(member, template);
     }
 
@@ -43,7 +44,12 @@ public Page<Template> findAllByMemberId(Long memberId, Pageable pageable) {
     @Transactional
     public void cancelLike(Member member, long templateId) {
         Template template = templateRepository.fetchById(templateId);
+        if (!isLiked(member, template)) {
+            return;
+        }
+
         likesRepository.deleteByMemberAndTemplate(member, template);
+        template.cancelLike();
     }
 
     @Transactional
diff --git a/backend/src/main/java/codezap/template/domain/Template.java b/backend/src/main/java/codezap/template/domain/Template.java
index 4c4d590af..0e7a4c8a5 100644
--- a/backend/src/main/java/codezap/template/domain/Template.java
+++ b/backend/src/main/java/codezap/template/domain/Template.java
@@ -15,7 +15,7 @@
 import jakarta.persistence.OneToMany;
 
 import org.hibernate.annotations.ColumnDefault;
-import org.hibernate.annotations.Formula;
+import org.hibernate.annotations.DynamicUpdate;
 
 import codezap.category.domain.Category;
 import codezap.global.auditing.BaseTimeEntity;
@@ -27,12 +27,15 @@
 import lombok.NoArgsConstructor;
 
 @Entity
+@DynamicUpdate
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor
 @Getter
 @EqualsAndHashCode(of = "id", callSuper = false)
 public class Template extends BaseTimeEntity {
 
+    private static final Long LIKES_COUNT_DEFAULT = 0L;
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
@@ -52,7 +55,8 @@ public class Template extends BaseTimeEntity {
     @OneToMany(mappedBy = "template")
     private List<SourceCode> sourceCodes = new ArrayList<>();
 
-    @Formula("(select count(*) from likes where likes.template_id = id)")
+    @Column
+    @ColumnDefault("0")
     private Long likesCount;
 
     @Column(nullable = false)
@@ -82,4 +86,15 @@ public boolean matchMember(Member member) {
     public boolean isPrivate() {
         return visibility == Visibility.PRIVATE;
     }
+
+    public void increaseLike() {
+        this.likesCount++;
+    }
+
+    public void cancelLike() {
+        if (this.likesCount <= LIKES_COUNT_DEFAULT) {
+            return;
+        }
+        this.likesCount--;
+    }
 }
diff --git a/backend/src/main/resources/db/migration/V9__like_column_denormalization.sql b/backend/src/main/resources/db/migration/V9__like_column_denormalization.sql
new file mode 100644
index 000000000..b47a60f92
--- /dev/null
+++ b/backend/src/main/resources/db/migration/V9__like_column_denormalization.sql
@@ -0,0 +1,8 @@
+ALTER TABLE template ADD COLUMN likes_count BIGINT DEFAULT 0;
+
+UPDATE template t
+SET likes_count = (
+    SELECT COUNT(1)
+    FROM likes l
+    WHERE l.template_id = t.id
+);
diff --git a/backend/src/test/java/codezap/likes/service/LikesServiceTest.java b/backend/src/test/java/codezap/likes/service/LikesServiceTest.java
index e78549281..9ac547ed1 100644
--- a/backend/src/test/java/codezap/likes/service/LikesServiceTest.java
+++ b/backend/src/test/java/codezap/likes/service/LikesServiceTest.java
@@ -1,7 +1,6 @@
 package codezap.likes.service;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.junit.jupiter.api.Assertions.assertAll;
 
 import java.util.List;
@@ -69,11 +68,9 @@ class CancelLikesTest {
         @DisplayName("성공")
         void success() {
             Member member = memberRepository.save(MemberFixture.getFirstMember());
-            Template template = templateRepository.save(TemplateFixture.get(
-                    member,
-                    categoryRepository.save(CategoryFixture.getFirstCategory())
-            ));
-            likesRepository.save(new Likes(null, template, member));
+            Category category = categoryRepository.save(CategoryFixture.getFirstCategory());
+            Template template = templateRepository.save(TemplateFixture.get(member, category));
+            likesService.like(member, template.getId());
 
             likesService.cancelLike(member, template.getId());
 
@@ -81,18 +78,17 @@ void success() {
         }
 
         @Test
-        @DisplayName("성공: 여러번 좋아요를 취소해도 정상 동작으로 판단")
-        void multipleLikes() {
+        @DisplayName("성공: 본인의 좋아요만 취소 가능")
+        void cancelMyLikes() {
             Member member = memberRepository.save(MemberFixture.getFirstMember());
-            Template template = templateRepository.save(TemplateFixture.get(
-                    member,
-                    categoryRepository.save(CategoryFixture.getFirstCategory())
-            ));
+            Member otherMember = memberRepository.save(MemberFixture.getSecondMember());
+            Category category = categoryRepository.save(CategoryFixture.getFirstCategory());
+            Template template = templateRepository.save(TemplateFixture.get(member, category));
 
+            likesService.like(otherMember, template.getId());
             likesService.cancelLike(member, template.getId());
 
-            assertThatCode(() -> likesService.cancelLike(member, template.getId()))
-                    .doesNotThrowAnyException();
+            assertThat(likesRepository.countByTemplate(template)).isEqualTo(1L);
         }
     }
 
@@ -109,7 +105,7 @@ void successWithLike() {
                     categoryRepository.save(CategoryFixture.getFirstCategory())
             ));
 
-            likesRepository.save(new Likes(null, template, member));
+            likesRepository.save(new Likes(template, member));
 
             assertThat(likesService.isLiked(member, template)).isTrue();
         }
diff --git a/backend/src/test/java/codezap/template/domain/TemplateTest.java b/backend/src/test/java/codezap/template/domain/TemplateTest.java
index c4515b271..eb72f6173 100644
--- a/backend/src/test/java/codezap/template/domain/TemplateTest.java
+++ b/backend/src/test/java/codezap/template/domain/TemplateTest.java
@@ -1,6 +1,7 @@
 package codezap.template.domain;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -68,4 +69,44 @@ void isPrivateFalse() {
             assertThat(actual).isFalse();
         }
     }
+
+    @Test
+    @DisplayName("좋아요 갱신 성공")
+    void increaseLike() {
+        Member member = MemberFixture.getFirstMember();
+        Template template = TemplateFixture.get(member, Category.createDefaultCategory(member));
+
+        template.increaseLike();
+
+        assertThat(template.getLikesCount()).isEqualTo(1L);
+    }
+
+    @Nested
+    @DisplayName("좋아요 취소")
+    class CancelLike {
+
+        @Test
+        @DisplayName("좋아요 취소 성공")
+        void cancelLike() {
+            Member member = MemberFixture.getFirstMember();
+            Template template = TemplateFixture.get(member, Category.createDefaultCategory(member));
+            template.increaseLike();
+            template.increaseLike();
+
+            template.cancelLike();
+
+            assertThat(template.getLikesCount()).isEqualTo(1L);
+        }
+
+        @Test
+        @DisplayName("좋아요 취소 성공: 이미 count가 0인 경우도 성공")
+        void cancelLikeWhenLikeAlreadyFail() {
+            Member member = MemberFixture.getFirstMember();
+            Template template = TemplateFixture.get(member, Category.createDefaultCategory(member));
+
+            template.cancelLike();
+
+            assertThat(template.getLikesCount()).isZero();
+        }
+    }
 }
diff --git a/backend/src/test/java/codezap/template/service/TemplateServiceTest.java b/backend/src/test/java/codezap/template/service/TemplateServiceTest.java
index 5278321ef..db1f55716 100644
--- a/backend/src/test/java/codezap/template/service/TemplateServiceTest.java
+++ b/backend/src/test/java/codezap/template/service/TemplateServiceTest.java
@@ -21,7 +21,7 @@
 import codezap.fixture.TemplateFixture;
 import codezap.global.ServiceTest;
 import codezap.global.exception.CodeZapException;
-import codezap.likes.domain.Likes;
+import codezap.likes.service.LikesService;
 import codezap.member.domain.Member;
 import codezap.template.domain.Template;
 import codezap.template.domain.Visibility;
@@ -34,6 +34,9 @@ class TemplateServiceTest extends ServiceTest {
     @Autowired
     private TemplateService sut;
 
+    @Autowired
+    private LikesService likesService;
+
     @Nested
     @DisplayName("템플릿 생성")
     class CreateTemplate {
@@ -182,11 +185,7 @@ private void saveTemplates5(Category category) {
 
         private void likeTemplate(long templateId, long likesCount) {
             for (long memberId = 1L; memberId <= likesCount; memberId++) {
-                likesRepository.save(new Likes(
-                        null,
-                        templateRepository.fetchById(templateId),
-                        memberRepository.fetchById(memberId)
-                ));
+                likesService.like(memberRepository.fetchById(memberId), templateId);
             }
         }
     }

From 8420e6791683c1b29134768eea494ddb5db29e45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=A0=95=ED=9A=8C=EC=84=B1?= <ghltjd3@gmail.com>
Date: Thu, 14 Nov 2024 11:31:04 +0900
Subject: [PATCH 4/8] =?UTF-8?q?=08=EC=9D=91=EB=8B=B5=20=ED=97=A4=EB=8D=94?=
 =?UTF-8?q?=EC=97=90=20hostname=20=EB=B3=80=EC=88=98=20=EC=B6=94=EA=B0=80?=
 =?UTF-8?q?=20(#868)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 backend/submodules/private | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/submodules/private b/backend/submodules/private
index c434d76a4..5ed274407 160000
--- a/backend/submodules/private
+++ b/backend/submodules/private
@@ -1 +1 @@
-Subproject commit c434d76a4712b6d3299525142b963bc0cbd8ee74
+Subproject commit 5ed274407079c654aedbb25249b2f9919008c8e9

From 73b4e0f897c229d5e873666d4f8119cd517fcdad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=A0=95=ED=9A=8C=EC=84=B1?= <ghltjd3@gmail.com>
Date: Thu, 14 Nov 2024 11:37:08 +0900
Subject: [PATCH 5/8] =?UTF-8?q?=EB=B0=B1=EC=97=94=EB=93=9C=20=EB=A1=9C?=
 =?UTF-8?q?=EA=B7=B8=20=EB=A6=AC=ED=8C=A9=ED=86=A0=EB=A7=81=20(#859)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../exception/GlobalExceptionHandler.java     |  9 +-
 .../global/logger/RequestResponseLogger.java  | 84 +++++++++++++++----
 .../logger/console/console-appender.xml       | 11 ++-
 .../resources/logger/file/error-appender.xml  |  2 +-
 .../resources/logger/file/info-appender.xml   |  4 +-
 .../resources/logger/file/warn-appender.xml   |  2 +-
 .../codezap/template/domain/TemplateTest.java |  1 -
 backend/submodules/private                    |  2 +-
 8 files changed, 83 insertions(+), 32 deletions(-)

diff --git a/backend/src/main/java/codezap/global/exception/GlobalExceptionHandler.java b/backend/src/main/java/codezap/global/exception/GlobalExceptionHandler.java
index 622303309..0d5bb09f2 100644
--- a/backend/src/main/java/codezap/global/exception/GlobalExceptionHandler.java
+++ b/backend/src/main/java/codezap/global/exception/GlobalExceptionHandler.java
@@ -33,7 +33,7 @@ public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
     @ExceptionHandler
     public ResponseEntity<ProblemDetail> handleCodeZapException(CodeZapException codeZapException) {
-        log.info("[CodeZapException] {}가 발생했습니다.", codeZapException.getClass().getName(), codeZapException);
+        log.warn("[CodeZapException] {}: {}", codeZapException.getClass().getName(), codeZapException.getMessage());
 
         return ResponseEntity.status(codeZapException.getErrorCode().getHttpStatus())
                 .body(codeZapException.toProblemDetail());
@@ -43,7 +43,7 @@ public ResponseEntity<ProblemDetail> handleCodeZapException(CodeZapException cod
     protected ResponseEntity<Object> handleMethodArgumentNotValid(
             MethodArgumentNotValidException exception, HttpHeaders headers, HttpStatusCode status, WebRequest request
     ) {
-        log.info("[MethodArgumentNotValidException] {}가 발생했습니다. \n", exception.getClass().getName(), exception);
+        log.warn("[MethodArgumentNotValidException] {}: {}", exception.getClass().getName(), exception.getMessage());
 
         BindingResult bindingResult = exception.getBindingResult();
         List<String> errorMessages = bindingResult.getAllErrors().stream()
@@ -58,7 +58,8 @@ protected ResponseEntity<Object> handleMethodArgumentNotValid(
 
     @Override
     protected ResponseEntity<Object> handleHttpMessageNotReadable(
-            HttpMessageNotReadableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
+            HttpMessageNotReadableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request
+    ) {
         String exceptionMessage = "잘못된 JSON 형식입니다.";
         if (ex.getCause() instanceof JsonMappingException jsonMappingException) {
             exceptionMessage = jsonMappingException.getPath().stream()
@@ -75,7 +76,7 @@ protected ResponseEntity<Object> handleHttpMessageNotReadable(
 
     @ExceptionHandler
     public ResponseEntity<ProblemDetail> handleException(Exception exception) {
-        log.error("[Exception] 예상치 못한 오류 {} 가 발생했습니다.", exception.getClass().getName(), exception);
+        log.error("[Exception] 예상치 못한 오류 {} 가 발생했습니다. \n", exception.getClass().getName(), exception);
         CodeZapException codeZapException =
                 new CodeZapException(ErrorCode.INTERNAL_SERVER_ERROR, "서버에서 예상치 못한 오류가 발생하였습니다.");
         return ResponseEntity.internalServerError()
diff --git a/backend/src/main/java/codezap/global/logger/RequestResponseLogger.java b/backend/src/main/java/codezap/global/logger/RequestResponseLogger.java
index aead953b7..fdfce8579 100644
--- a/backend/src/main/java/codezap/global/logger/RequestResponseLogger.java
+++ b/backend/src/main/java/codezap/global/logger/RequestResponseLogger.java
@@ -1,7 +1,9 @@
 package codezap.global.logger;
 
 import java.io.IOException;
-import java.util.stream.Collectors;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
 
 import jakarta.servlet.FilterChain;
 import jakarta.servlet.ServletException;
@@ -14,6 +16,9 @@
 import org.springframework.web.util.ContentCachingRequestWrapper;
 import org.springframework.web.util.ContentCachingResponseWrapper;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
@@ -21,6 +26,11 @@
 @Order(2)
 public class RequestResponseLogger extends OncePerRequestFilter {
 
+    private static final int ERROR_CODE = 500;
+    private static final int WARN_CODE = 400;
+
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
             throws ServletException, IOException {
@@ -31,29 +41,69 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
         filterChain.doFilter(requestWrapper, responseWrapper);
         long duration = System.currentTimeMillis() - startTime;
 
-        log.info("[Request] {} {}, 헤더 값: {} \n", request.getMethod(), request.getRequestURI(),
-                getHeaderAndValue(requestWrapper));
-        log.info("[Response] Status: {}, Duration: {}ms, 헤더 값: {} \n", response.getStatus(), duration,
-                getHeaderAndValue(responseWrapper));
+        logResponse(request, response, requestWrapper, duration, responseWrapper);
 
         responseWrapper.copyBodyToResponse();
     }
 
-    private String getHeaderAndValue(ContentCachingRequestWrapper requestWrapper) {
-        StringBuilder headerAndValue = new StringBuilder();
-        requestWrapper.getHeaderNames().asIterator().forEachRemaining(headerName -> {
-            String headerValue = requestWrapper.getHeader(headerName);
-            headerAndValue.append(headerName).append(" : ").append(headerValue).append("\n");
-        });
+    private void logResponse(HttpServletRequest request, HttpServletResponse response,
+            ContentCachingRequestWrapper requestWrapper, long duration, ContentCachingResponseWrapper responseWrapper
+    ) {
+        int status = response.getStatus();
+        String requestMessage = String.format(
+                "[Request] %s %s, 헤더 값: %s",
+                request.getMethod(),
+                request.getRequestURI(),
+                getHeaderAsJson(requestWrapper));
+        String responseMessage = String.format(
+                "[Response] status: %d, duration: %dms, headers: %s",
+                status,
+                duration,
+                getHeaderAsJson(responseWrapper));
+
+        logByStatus(status, requestMessage, responseMessage);
+    }
+
+    private String getHeaderAsJson(ContentCachingRequestWrapper requestWrapper) {
+        Map<String, String> headersMap = new HashMap<>();
+        Enumeration<String> headerNames = requestWrapper.getHeaderNames();
+        while (headerNames.hasMoreElements()) {
+            String headerName = headerNames.nextElement();
+            headersMap.put(headerName, requestWrapper.getHeader(headerName));
+        }
+        return convertMapToJson(headersMap);
+    }
+
+    private String getHeaderAsJson(ContentCachingResponseWrapper responseWrapper) {
+        Map<String, String> headersMap = new HashMap<>();
+        for (String headerName : responseWrapper.getHeaderNames()) {
+            headersMap.put(headerName, responseWrapper.getHeader(headerName));
+        }
+        return convertMapToJson(headersMap);
+    }
 
-        return headerAndValue.toString();
+    private String convertMapToJson(Map<String, String> map) {
+        try {
+            return objectMapper.writeValueAsString(map);
+        } catch (JsonProcessingException e) {
+            log.error("헤더 정보를 JSON으로 변환하는 중 오류 발생", e);
+            return "{}";
+        }
     }
 
-    private String getHeaderAndValue(ContentCachingResponseWrapper requestWrapper) {
-        return requestWrapper.getHeaderNames().stream().map(headerName -> {
-            String headerValue = requestWrapper.getHeader(headerName);
-            return headerName + " : " + headerValue;
-        }).collect(Collectors.joining("\n"));
+    private void logByStatus(int status, String requestMessage, String responseMessage) {
+        if (status >= ERROR_CODE) {
+            log.error(requestMessage);
+            log.error(responseMessage);
+            return;
+        }
+        if (status >= WARN_CODE) {
+            log.warn(requestMessage);
+            log.warn(responseMessage);
+            return;
+        }
+        log.info(requestMessage);
+        log.info(responseMessage);
     }
 
     @Override
diff --git a/backend/src/main/resources/logger/console/console-appender.xml b/backend/src/main/resources/logger/console/console-appender.xml
index 09bf77425..ee5834005 100644
--- a/backend/src/main/resources/logger/console/console-appender.xml
+++ b/backend/src/main/resources/logger/console/console-appender.xml
@@ -1,9 +1,12 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-
-<included>
+<configuration>
     <appender name="console-appender" class="ch.qos.logback.core.ConsoleAppender">
         <layout class="ch.qos.logback.classic.PatternLayout">
-            <pattern>[%highlight(%level)][%d{MM-dd HH:mm:ss}][%magenta(%8X{correlationId})][%highlight(%replace(%logger{20}){'\\w\\.', ''})] %msg %n</pattern>
+            <pattern>[%level][%d{MM-dd HH:mm:ss}][%X{correlationId}][%logger{20}] %msg%n</pattern>
         </layout>
     </appender>
-</included>
+
+    <root level="INFO">
+        <appender-ref ref="console-appender" />
+    </root>
+</configuration>
diff --git a/backend/src/main/resources/logger/file/error-appender.xml b/backend/src/main/resources/logger/file/error-appender.xml
index d37a63be5..616f954ba 100644
--- a/backend/src/main/resources/logger/file/error-appender.xml
+++ b/backend/src/main/resources/logger/file/error-appender.xml
@@ -12,7 +12,7 @@
         </filter>
 
         <encoder>
-            <pattern>[%boldRed(%level)][%d{MM-dd HH:mm:ss}][%magenta(%8X{correlationId})][%boldRed(%replace(%logger{20}){'\\w\\.', ''}:%line)] %msg %n</pattern>
+            <pattern>[%level][%d{MM-dd HH:mm:ss}][%X{correlationId}][%logger{20}] %msg%exception{full}%n</pattern>
         </encoder>
 
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
diff --git a/backend/src/main/resources/logger/file/info-appender.xml b/backend/src/main/resources/logger/file/info-appender.xml
index f3f03bd62..2c95fa323 100644
--- a/backend/src/main/resources/logger/file/info-appender.xml
+++ b/backend/src/main/resources/logger/file/info-appender.xml
@@ -2,7 +2,6 @@
 
 <included>
     <appender name="info-appender" class="ch.qos.logback.core.rolling.RollingFileAppender">
-
         <file>${LOG_FILE_PATH}/info.log</file>
 
         <filter class="ch.qos.logback.classic.filter.LevelFilter">
@@ -12,7 +11,7 @@
         </filter>
 
         <encoder>
-            <pattern>[%cyan(%level)][%d{MM-dd HH:mm:ss}][%magenta(%8X{correlationId})][%blue(%replace(%logger{20}){'\\w\\.', ''})] %msg %n</pattern>
+            <pattern>[%level][%d{MM-dd HH:mm:ss}][%X{correlationId}][%logger{20}] %msg%n</pattern>
         </encoder>
 
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
@@ -20,6 +19,5 @@
             <totalSizeCap>5GB</totalSizeCap>
             <maxHistory>30</maxHistory>
         </rollingPolicy>
-
     </appender>
 </included>
diff --git a/backend/src/main/resources/logger/file/warn-appender.xml b/backend/src/main/resources/logger/file/warn-appender.xml
index 4a3b066a0..7cdfedbad 100644
--- a/backend/src/main/resources/logger/file/warn-appender.xml
+++ b/backend/src/main/resources/logger/file/warn-appender.xml
@@ -12,7 +12,7 @@
         </filter>
 
         <encoder>
-            <pattern>[%red(%level)][%d{MM-dd HH:mm:ss}][%magenta(%8X{correlationId})][%red(%replace(%logger{20}){'\\w\\.', ''}:%line)] %msg %n</pattern>
+            <pattern>[%level][%d{MM-dd HH:mm:ss}][%X{correlationId}][%logger{20}] %msg%exception{full}%n</pattern>
         </encoder>
 
         <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
diff --git a/backend/src/test/java/codezap/template/domain/TemplateTest.java b/backend/src/test/java/codezap/template/domain/TemplateTest.java
index eb72f6173..39b4863ec 100644
--- a/backend/src/test/java/codezap/template/domain/TemplateTest.java
+++ b/backend/src/test/java/codezap/template/domain/TemplateTest.java
@@ -1,7 +1,6 @@
 package codezap.template.domain;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
diff --git a/backend/submodules/private b/backend/submodules/private
index 5ed274407..c49d0183a 160000
--- a/backend/submodules/private
+++ b/backend/submodules/private
@@ -1 +1 @@
-Subproject commit 5ed274407079c654aedbb25249b2f9919008c8e9
+Subproject commit c49d0183a5747845da7900a67a8220c020fce1d7

From 595da34d6bbd8bb1cac40fd4b9008cde86bfdda5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=A0=95=ED=9A=8C=EC=84=B1?= <ghltjd3@gmail.com>
Date: Thu, 14 Nov 2024 11:46:52 +0900
Subject: [PATCH 6/8] =?UTF-8?q?=20backend=20CD=20=ED=95=B4=EA=B2=B0=20(#91?=
 =?UTF-8?q?1)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 backend/submodules/private | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/submodules/private b/backend/submodules/private
index c49d0183a..5ed274407 160000
--- a/backend/submodules/private
+++ b/backend/submodules/private
@@ -1 +1 @@
-Subproject commit c49d0183a5747845da7900a67a8220c020fce1d7
+Subproject commit 5ed274407079c654aedbb25249b2f9919008c8e9

From 2b903519209fd9bacf631904706169a9da17d0c5 Mon Sep 17 00:00:00 2001
From: Moly <102847513+jminkkk@users.noreply.github.com>
Date: Thu, 14 Nov 2024 21:04:36 +0900
Subject: [PATCH 7/8] =?UTF-8?q?=ED=8E=98=EC=9D=B4=EC=A7=80=EB=84=A4?=
 =?UTF-8?q?=EC=9D=B4=EC=85=98=20=EC=B2=98=EB=A6=AC=20=EC=8B=9C=20=EC=B5=9C?=
 =?UTF-8?q?=EB=8C=80=20=EB=8B=A4=EC=9D=8C=20=ED=8E=98=EC=9D=B4=EC=A7=80=20?=
 =?UTF-8?q?=EC=88=98=EB=A5=BC=205=EA=B0=9C=EB=A1=9C=20=EC=A0=9C=ED=95=9C?=
 =?UTF-8?q?=20(#902)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../codezap/global/pagination/FixedPage.java  |  6 ++
 .../global/pagination/FixedPageCounter.java   | 32 ++++++++
 .../likes/repository/LikesJpaRepository.java  | 11 ---
 .../likes/repository/LikesRepository.java     |  6 --
 .../codezap/likes/service/LikesService.java   |  6 +-
 .../response/FindAllTemplatesResponse.java    |  6 +-
 .../TemplateQueryDSLRepository.java           | 68 +++++++++++-----
 .../repository/TemplateRepository.java        |  8 +-
 .../template/service/TemplateService.java     |  8 +-
 .../facade/TemplateApplicationService.java    | 17 ++--
 .../pagination/FixedPageCounterTest.java      | 70 ++++++++++++++++
 .../global/repository/RepositoryTest.java     |  5 +-
 .../likes/repository/LikesRepositoryTest.java | 34 --------
 .../likes/service/LikesServiceTest.java       | 29 +------
 .../controller/TemplateControllerTest.java    | 15 ++--
 .../repository/TemplateRepositoryTest.java    | 38 +++++++++
 .../TemplateSearchRepositoryTest.java         | 79 ++++++++++---------
 .../service/TemplateSearchServiceTest.java    | 65 ++++++++-------
 .../template/service/TemplateServiceTest.java | 41 ++++++++--
 .../TemplateApplicationServiceTest.java       |  4 +-
 backend/src/test/resources/search.sql         | 15 +++-
 21 files changed, 352 insertions(+), 211 deletions(-)
 create mode 100644 backend/src/main/java/codezap/global/pagination/FixedPage.java
 create mode 100644 backend/src/main/java/codezap/global/pagination/FixedPageCounter.java
 create mode 100644 backend/src/test/java/codezap/global/pagination/FixedPageCounterTest.java

diff --git a/backend/src/main/java/codezap/global/pagination/FixedPage.java b/backend/src/main/java/codezap/global/pagination/FixedPage.java
new file mode 100644
index 000000000..8ab2a87ca
--- /dev/null
+++ b/backend/src/main/java/codezap/global/pagination/FixedPage.java
@@ -0,0 +1,6 @@
+package codezap.global.pagination;
+
+import java.util.List;
+
+public record FixedPage<T> (List<T> contents, int nextPages) {
+}
diff --git a/backend/src/main/java/codezap/global/pagination/FixedPageCounter.java b/backend/src/main/java/codezap/global/pagination/FixedPageCounter.java
new file mode 100644
index 000000000..5e0565412
--- /dev/null
+++ b/backend/src/main/java/codezap/global/pagination/FixedPageCounter.java
@@ -0,0 +1,32 @@
+package codezap.global.pagination;
+
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Component;
+
+import com.querydsl.core.types.dsl.BooleanExpression;
+import com.querydsl.core.types.dsl.EntityPathBase;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+@Component
+public class FixedPageCounter {
+
+    private static final int MAXIMUM_PAGE = 5;
+
+    public int countNextFixedPage(
+            JPAQueryFactory queryFactory,
+            EntityPathBase<?> entityPath,
+            Pageable pageable,
+            BooleanExpression... conditions
+    ) {
+        int maximumElementsCount = pageable.getPageSize() * MAXIMUM_PAGE;
+        long nextFixedElementCounts = queryFactory
+                .selectFrom(entityPath)
+                .where(conditions)
+                .offset(pageable.getOffset())
+                .limit(maximumElementsCount)
+                .fetch()
+                .size();
+
+        return (int) Math.ceil((double) nextFixedElementCounts / pageable.getPageSize());
+    }
+}
diff --git a/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java b/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java
index 196dadf12..f13bd5108 100644
--- a/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java
+++ b/backend/src/main/java/codezap/likes/repository/LikesJpaRepository.java
@@ -1,10 +1,6 @@
 package codezap.likes.repository;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
 
 import codezap.likes.domain.Likes;
 import codezap.member.domain.Member;
@@ -17,11 +13,4 @@ public interface LikesJpaRepository extends JpaRepository<Likes, Long> {
     boolean existsByMemberAndTemplate(Member member, Template template);
 
     long countByTemplate(Template template);
-
-    @Query("""
-            SELECT l.template
-            FROM Likes l
-            WHERE l.member.id = :memberId AND (l.template.member.id = :memberId OR l.template.visibility = 'PUBLIC')
-            """)
-    Page<Template> findAllByMemberId(@Param(value = "memberId") Long memberId, Pageable pageable);
 }
diff --git a/backend/src/main/java/codezap/likes/repository/LikesRepository.java b/backend/src/main/java/codezap/likes/repository/LikesRepository.java
index 1c4e1b690..3072832cc 100644
--- a/backend/src/main/java/codezap/likes/repository/LikesRepository.java
+++ b/backend/src/main/java/codezap/likes/repository/LikesRepository.java
@@ -2,8 +2,6 @@
 
 import java.util.List;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Repository;
 
 import codezap.likes.domain.Likes;
@@ -37,8 +35,4 @@ public void deleteByMemberAndTemplate(Member member, Template template) {
     public void deleteAllByTemplateIds(List<Long> templateIds) {
         likesQueryDslRepository.deleteAllByTemplateIds(templateIds);
     }
-
-    public Page<Template> findAllByMemberId(Long memberId, Pageable pageable) {
-        return likesJpaRepository.findAllByMemberId(memberId, pageable);
-    }
 }
diff --git a/backend/src/main/java/codezap/likes/service/LikesService.java b/backend/src/main/java/codezap/likes/service/LikesService.java
index 62f6c4e8c..2ea32c641 100644
--- a/backend/src/main/java/codezap/likes/service/LikesService.java
+++ b/backend/src/main/java/codezap/likes/service/LikesService.java
@@ -2,11 +2,11 @@
 
 import java.util.List;
 
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import codezap.global.pagination.FixedPage;
 import codezap.likes.domain.Likes;
 import codezap.likes.repository.LikesRepository;
 import codezap.member.domain.Member;
@@ -37,10 +37,6 @@ public boolean isLiked(Member member, Template template) {
         return likesRepository.existsByMemberAndTemplate(member, template);
     }
 
-    public Page<Template> findAllByMemberId(Long memberId, Pageable pageable) {
-        return likesRepository.findAllByMemberId(memberId, pageable);
-    }
-
     @Transactional
     public void cancelLike(Member member, long templateId) {
         Template template = templateRepository.fetchById(templateId);
diff --git a/backend/src/main/java/codezap/template/dto/response/FindAllTemplatesResponse.java b/backend/src/main/java/codezap/template/dto/response/FindAllTemplatesResponse.java
index 87c8be08a..f48758f28 100644
--- a/backend/src/main/java/codezap/template/dto/response/FindAllTemplatesResponse.java
+++ b/backend/src/main/java/codezap/template/dto/response/FindAllTemplatesResponse.java
@@ -5,10 +5,8 @@
 import io.swagger.v3.oas.annotations.media.Schema;
 
 public record FindAllTemplatesResponse(
-        @Schema(description = "전체 페이지 개수", example = "1")
-        int totalPages,
-        @Schema(description = "총 템플릿 개수", example = "134")
-        long totalElements,
+        @Schema(description = "최대 페이지 개수, 최대 5개입니다.", example = "1")
+        int paginationSizes,
         @Schema(description = "템플릿 목록")
         List<FindAllTemplateItemResponse> templates
 ) {
diff --git a/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java b/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java
index e073b11c5..5529c8f54 100644
--- a/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java
+++ b/backend/src/main/java/codezap/template/repository/TemplateQueryDSLRepository.java
@@ -1,18 +1,17 @@
 package codezap.template.repository;
 
-import static codezap.template.domain.QTemplate.template;
-
 import java.util.List;
-import java.util.Objects;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Repository;
 
 import com.querydsl.core.types.dsl.BooleanExpression;
 import com.querydsl.jpa.impl.JPAQueryFactory;
 
+import codezap.global.pagination.FixedPage;
+import codezap.global.pagination.FixedPageCounter;
+import codezap.likes.domain.QLikes;
+import codezap.template.domain.QTemplate;
 import codezap.template.domain.Template;
 import codezap.template.domain.Visibility;
 import lombok.RequiredArgsConstructor;
@@ -23,8 +22,9 @@ public class TemplateQueryDSLRepository {
 
     private final JPAQueryFactory queryFactory;
     private final TemplateSearchExpressionProvider expressionProvider;
+    private final FixedPageCounter fixedPageCounter;
 
-    public Page<Template> findTemplates(
+    public FixedPage<Template> findTemplates(
             Long memberId,
             String keyword,
             Long categoryId,
@@ -33,8 +33,8 @@ public Page<Template> findTemplates(
             Pageable pageable
     ) {
         List<Template> content = getTemplates(memberId, keyword, categoryId, tagIds, visibility, pageable);
-        long count = count(memberId, keyword, categoryId, tagIds, visibility);
-        return new PageImpl<>(content, pageable, count);
+        int nextFixedPage = countMaxPageOfTemplates(memberId, keyword, categoryId, tagIds, visibility, pageable);
+        return new FixedPage<>(content, nextFixedPage);
     }
 
     private List<Template> getTemplates(
@@ -45,10 +45,9 @@ private List<Template> getTemplates(
             Visibility visibility,
             Pageable pageable
     ) {
-        return queryFactory
-                .selectFrom(template)
-                .leftJoin(template.category).fetchJoin()
-                .leftJoin(template.member).fetchJoin()
+        return queryFactory.selectFrom(QTemplate.template)
+                .leftJoin(QTemplate.template.category).fetchJoin()
+                .leftJoin(QTemplate.template.member).fetchJoin()
                 .where(matchesKeyword(memberId, keyword, categoryId, tagIds, visibility))
                 .orderBy(TemplateOrderSpecifierUtils.getOrderSpecifier(pageable.getSort()))
                 .offset(pageable.getOffset())
@@ -56,18 +55,20 @@ private List<Template> getTemplates(
                 .fetch();
     }
 
-    private long count(
+    private int countMaxPageOfTemplates(
             Long memberId,
             String keyword,
             Long categoryId,
             List<Long> tagIds,
-            Visibility visibility
+            Visibility visibility,
+            Pageable pageable
     ) {
-        return Objects.requireNonNull(queryFactory
-                .select(template.count())
-                .from(template)
-                .where(matchesKeyword(memberId, keyword, categoryId, tagIds, visibility))
-                .fetchOne());
+        return fixedPageCounter.countNextFixedPage(
+                queryFactory,
+                QTemplate.template,
+                pageable,
+                matchesKeyword(memberId, keyword, categoryId, tagIds, visibility)
+        );
     }
 
     private BooleanExpression[] matchesKeyword(
@@ -85,5 +86,34 @@ private BooleanExpression[] matchesKeyword(
                 expressionProvider.matchesKeyword(keyword)
         };
     }
+
+    public FixedPage<Template> findAllLikedByMemberId(Long memberId, Pageable pageable) {
+        List<Template> content = queryFactory.select(QLikes.likes.template)
+                .from(QLikes.likes)
+                .where(isLikedTemplateByMember(memberId))
+                .orderBy(TemplateOrderSpecifierUtils.getOrderSpecifier(pageable.getSort()))
+                .offset(pageable.getOffset())
+                .limit(pageable.getPageSize())
+                .fetch();
+
+        return new FixedPage<>(content, countMaxPageOfLikeTemplates(memberId, pageable));
+    }
+
+    private int countMaxPageOfLikeTemplates(Long memberId, Pageable pageable) {
+        return fixedPageCounter.countNextFixedPage(
+                queryFactory,
+                QLikes.likes,
+                pageable,
+                isLikedTemplateByMember(memberId)
+        );
+    }
+
+    private static BooleanExpression isLikedTemplateByMember(Long memberId) {
+        BooleanExpression isLikedByMemberId = QLikes.likes.member.id.eq(memberId);
+        BooleanExpression isLikedTemplateByMemberId = QLikes.likes.template.member.id.eq(memberId);
+        BooleanExpression isTemplatePublic = QLikes.likes.template.visibility.eq(Visibility.PUBLIC);
+
+        return isLikedByMemberId.and(isLikedTemplateByMemberId.or(isTemplatePublic));
+    }
 }
 
diff --git a/backend/src/main/java/codezap/template/repository/TemplateRepository.java b/backend/src/main/java/codezap/template/repository/TemplateRepository.java
index f17f2a1fb..fc7da4626 100644
--- a/backend/src/main/java/codezap/template/repository/TemplateRepository.java
+++ b/backend/src/main/java/codezap/template/repository/TemplateRepository.java
@@ -2,12 +2,12 @@
 
 import java.util.List;
 
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Repository;
 
 import codezap.global.exception.CodeZapException;
 import codezap.global.exception.ErrorCode;
+import codezap.global.pagination.FixedPage;
 import codezap.template.domain.Template;
 import codezap.template.domain.Visibility;
 import lombok.RequiredArgsConstructor;
@@ -28,12 +28,16 @@ public List<Template> findByMemberId(Long id) {
         return templateJpaRepository.findByMemberId(id);
     }
 
-    public Page<Template> findAll(
+    public FixedPage<Template> findAll(
             Long memberId, String keyword, Long categoryId, List<Long> tagIds, Visibility visibility, Pageable pageable
     ) {
         return templateQueryDSLRepository.findTemplates(memberId, keyword, categoryId, tagIds, visibility, pageable);
     }
 
+    public FixedPage<Template> findAllLikedByMemberId(Long memberId, Pageable pageable) {
+        return templateQueryDSLRepository.findAllLikedByMemberId(memberId, pageable);
+    }
+
     public boolean existsByCategoryId(Long categoryId) {
         return templateJpaRepository.existsByCategoryId(categoryId);
     }
diff --git a/backend/src/main/java/codezap/template/service/TemplateService.java b/backend/src/main/java/codezap/template/service/TemplateService.java
index b4d917c26..d13a6db45 100644
--- a/backend/src/main/java/codezap/template/service/TemplateService.java
+++ b/backend/src/main/java/codezap/template/service/TemplateService.java
@@ -3,7 +3,6 @@
 import java.util.HashSet;
 import java.util.List;
 
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -11,6 +10,7 @@
 import codezap.category.domain.Category;
 import codezap.global.exception.CodeZapException;
 import codezap.global.exception.ErrorCode;
+import codezap.global.pagination.FixedPage;
 import codezap.member.domain.Member;
 import codezap.template.domain.Template;
 import codezap.template.domain.Visibility;
@@ -45,7 +45,7 @@ public List<Template> getByMemberId(Long memberId) {
         return templateRepository.findByMemberId(memberId);
     }
 
-    public Page<Template> findAllBy(
+    public FixedPage<Template> findAllBy(
             Long memberId,
             String keyword,
             Long categoryId,
@@ -56,6 +56,10 @@ public Page<Template> findAllBy(
         return templateRepository.findAll(memberId, keyword, categoryId, tagIds, visibility, pageable);
     }
 
+    public FixedPage<Template> findAllByMemberId(Long memberId, Pageable pageable) {
+        return templateRepository.findAllLikedByMemberId(memberId, pageable);
+    }
+
     @Transactional
     public Template update(
             Member member,
diff --git a/backend/src/main/java/codezap/template/service/facade/TemplateApplicationService.java b/backend/src/main/java/codezap/template/service/facade/TemplateApplicationService.java
index 206a3b109..4c091ab88 100644
--- a/backend/src/main/java/codezap/template/service/facade/TemplateApplicationService.java
+++ b/backend/src/main/java/codezap/template/service/facade/TemplateApplicationService.java
@@ -4,7 +4,6 @@
 
 import jakarta.annotation.Nullable;
 
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -13,10 +12,10 @@
 import codezap.category.service.CategoryService;
 import codezap.global.exception.CodeZapException;
 import codezap.global.exception.ErrorCode;
+import codezap.global.pagination.FixedPage;
 import codezap.likes.service.LikedChecker;
 import codezap.likes.service.LikesService;
 import codezap.member.domain.Member;
-import codezap.member.service.MemberService;
 import codezap.tag.domain.Tag;
 import codezap.tag.service.TagService;
 import codezap.template.domain.SourceCode;
@@ -45,7 +44,6 @@ public class TemplateApplicationService {
     private final TagService tagService;
     private final ThumbnailService thumbnailService;
     private final LikesService likesService;
-    private final MemberService memberService;
 
     @Transactional
     public Long create(Member member, CreateTemplateRequest createTemplateRequest) {
@@ -94,7 +92,7 @@ public FindAllTemplatesResponse findAllBy(
             List<Long> tagIds,
             Pageable pageable
     ) {
-        Page<Template> templates = templateService.findAllBy(
+        FixedPage<Template> templates = templateService.findAllBy(
                 memberId, keyword, categoryId, tagIds, Visibility.PUBLIC, pageable
         );
         return makeAllTemplatesResponse(templates, (template) -> false);
@@ -108,7 +106,7 @@ public FindAllTemplatesResponse findAllBy(
             Pageable pageable,
             Member loginMember
     ) {
-        Page<Template> templates = templateService.findAllBy(
+        FixedPage<Template> templates = templateService.findAllBy(
                 memberId, keyword, categoryId, tagIds, getVisibilityLevel(memberId, loginMember), pageable
         );
         return makeAllTemplatesResponse(templates, (template -> likesService.isLiked(loginMember, template)));
@@ -123,18 +121,17 @@ private Visibility getVisibilityLevel(Long memberId, Member loginMember) {
     }
 
     public FindAllTemplatesResponse findAllByLiked(Long memberId, Pageable pageable) {
-        Page<Template> likeTemplate = likesService.findAllByMemberId(memberId, pageable);
+        FixedPage<Template> likeTemplate = templateService.findAllByMemberId(memberId, pageable);
         return makeAllTemplatesResponse(likeTemplate, (template -> true));
     }
 
-    private FindAllTemplatesResponse makeAllTemplatesResponse(Page<Template> page, LikedChecker likedChecker) {
-        List<Template> templates = page.getContent();
+    private FindAllTemplatesResponse makeAllTemplatesResponse(FixedPage<Template> page, LikedChecker likedChecker) {
+        List<Template> templates = page.contents();
         List<FindAllTemplateItemResponse> findAllTemplateByResponse =
                 getFindAllTemplateItemResponses(templates, likedChecker);
 
         return new FindAllTemplatesResponse(
-                page.getTotalPages(),
-                page.getTotalElements(),
+                page.nextPages(),
                 findAllTemplateByResponse);
     }
 
diff --git a/backend/src/test/java/codezap/global/pagination/FixedPageCounterTest.java b/backend/src/test/java/codezap/global/pagination/FixedPageCounterTest.java
new file mode 100644
index 000000000..0adf04886
--- /dev/null
+++ b/backend/src/test/java/codezap/global/pagination/FixedPageCounterTest.java
@@ -0,0 +1,70 @@
+package codezap.global.pagination;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import jakarta.persistence.EntityManager;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.test.context.jdbc.Sql;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+
+import codezap.global.querydsl.QueryDSLConfig;
+import codezap.global.rds.DataSourceConfig;
+import codezap.template.domain.QTemplate;
+
+@DataJpaTest
+@Import({DataSourceConfig.class, QueryDSLConfig.class, FixedPageCounter.class})
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+@Sql(scripts = "classpath:search.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD)
+class FixedPageCounterTest {
+
+    @Autowired
+    private EntityManager em;
+
+    private JPAQueryFactory queryFactory;
+    private FixedPageCounter fixedPageCounter;
+
+    @BeforeEach
+    void setUp() {
+        queryFactory = new JPAQueryFactory(em);
+        fixedPageCounter = new FixedPageCounter();
+    }
+
+    @Test
+    @DisplayName("페이지가 7개까지 있어도, 최대 5페이지까지만 카운팅")
+    void countNextFixedPage_WithPageSize10() {
+        PageRequest pageRequest = PageRequest.of(0, 1);
+        QTemplate template = QTemplate.template;
+
+        int nextFixedPage = fixedPageCounter.countNextFixedPage(
+                queryFactory,
+                template,
+                pageRequest
+        );
+
+        assertThat(nextFixedPage).isEqualTo(5);
+    }
+
+    @Test
+    @DisplayName("데이터가 최대 페이지보다 적을 경우, 1페이지 반환")
+    void countNextFixedPage_WithPageSize1() {
+        PageRequest pageRequest = PageRequest.of(0, 10);
+        QTemplate template = QTemplate.template;
+
+        int nextFixedPage = fixedPageCounter.countNextFixedPage(
+                queryFactory,
+                template,
+                pageRequest
+        );
+
+        assertThat(nextFixedPage).isEqualTo(1);
+    }
+}
diff --git a/backend/src/test/java/codezap/global/repository/RepositoryTest.java b/backend/src/test/java/codezap/global/repository/RepositoryTest.java
index 52bfc3238..95e891aaa 100644
--- a/backend/src/test/java/codezap/global/repository/RepositoryTest.java
+++ b/backend/src/test/java/codezap/global/repository/RepositoryTest.java
@@ -14,6 +14,7 @@
 
 import codezap.global.DatabaseIsolation;
 import codezap.global.auditing.JpaAuditingConfiguration;
+import codezap.global.pagination.FixedPageCounter;
 import codezap.global.querydsl.QueryDSLConfig;
 import codezap.global.rds.DataSourceConfig;
 import codezap.template.repository.TemplateSearchExpressionProvider;
@@ -29,7 +30,9 @@
         QueryDSLConfig.class,
         TemplateSearchExpressionProvider.class,
         LikeSearchStrategy.class,
-        FullTextSearchSearchStrategy.class})
+        FullTextSearchSearchStrategy.class,
+        FixedPageCounter.class
+})
 @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
 public @interface RepositoryTest {
 }
diff --git a/backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java b/backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java
index 748de9eac..d9ce28933 100644
--- a/backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java
+++ b/backend/src/test/java/codezap/likes/repository/LikesRepositoryTest.java
@@ -10,8 +10,6 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageRequest;
 
 import codezap.category.domain.Category;
 import codezap.category.repository.CategoryRepository;
@@ -201,36 +199,4 @@ void testDeleteByTemplateIds() {
             );
         }
     }
-
-    @Nested
-    @DisplayName("회원이 좋아요한 템플릿 조회 테스트")
-    class FindAllByMemberId {
-
-        @Test
-        @DisplayName("성공: 다른 사람의 private은 제외, 내 private은 포함")
-        void findAllByMemberId() {
-            // given
-            Member member = memberRepository.save(MemberFixture.getFirstMember());
-            Member otherMember = memberRepository.save(MemberFixture.getSecondMember());
-
-            Category category = categoryRepository.save(CategoryFixture.get(member));
-            Category otherCategory = categoryRepository.save(CategoryFixture.get(otherMember));
-
-            Template myPublicTemplate = templateRepository.save(TemplateFixture.get(member, category));
-            Template myPrivateTemplate = templateRepository.save(TemplateFixture.getPrivate(member, category));
-            Template otherPublicTemplate = templateRepository.save(TemplateFixture.get(otherMember, otherCategory));
-            Template otherPrivateTemplate = templateRepository.save(TemplateFixture.getPrivate(otherMember, otherCategory));
-
-            likesRepository.save(new Likes(myPublicTemplate, member));
-            likesRepository.save(new Likes(myPrivateTemplate, member));
-            likesRepository.save(new Likes(otherPublicTemplate, member));
-            likesRepository.save(new Likes(otherPrivateTemplate, member));
-
-            // when
-            Page<Template> actual = likesRepository.findAllByMemberId(member.getId(), PageRequest.of(0, 5));
-
-            // then
-            assertThat(actual).containsExactlyInAnyOrder(myPublicTemplate, myPrivateTemplate, otherPublicTemplate);
-        }
-    }
 }
diff --git a/backend/src/test/java/codezap/likes/service/LikesServiceTest.java b/backend/src/test/java/codezap/likes/service/LikesServiceTest.java
index 9ac547ed1..2e6fa2780 100644
--- a/backend/src/test/java/codezap/likes/service/LikesServiceTest.java
+++ b/backend/src/test/java/codezap/likes/service/LikesServiceTest.java
@@ -9,7 +9,6 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 
 import codezap.category.domain.Category;
@@ -17,6 +16,7 @@
 import codezap.fixture.MemberFixture;
 import codezap.fixture.TemplateFixture;
 import codezap.global.ServiceTest;
+import codezap.global.pagination.FixedPage;
 import codezap.likes.domain.Likes;
 import codezap.member.domain.Member;
 import codezap.template.domain.Template;
@@ -177,31 +177,4 @@ void deleteAllByTemplateIdsSuccess() {
             );
         }
     }
-
-    @Nested
-    @DisplayName("좋아요한 템플릿 조회")
-    class FindAllByMemberId {
-
-        @Test
-        @DisplayName("성공")
-        void findAllByMemberId() {
-            // given
-            Member member1 = memberRepository.save(MemberFixture.getFirstMember());
-            Member member2 = memberRepository.save(MemberFixture.getSecondMember());
-            Category category1 = categoryRepository.save(CategoryFixture.get(member1));
-            Category category2 = categoryRepository.save(CategoryFixture.get(member2));
-            Template template1 = templateRepository.save(TemplateFixture.get(member1, category1));
-            Template template2 = templateRepository.save(TemplateFixture.get(member1, category1));
-            Template template3 = templateRepository.save(TemplateFixture.get(member2, category2));
-            likesRepository.save(new Likes(template1, member1));
-            likesRepository.save(new Likes(template2, member2));
-            likesRepository.save(new Likes(template3, member1));
-
-            // when
-            Page<Template> actual = likesService.findAllByMemberId(member1.getId(), PageRequest.of(0, 5));
-
-            // then
-            assertThat(actual).containsExactlyInAnyOrder(template1, template3);
-        }
-    }
 }
diff --git a/backend/src/test/java/codezap/template/controller/TemplateControllerTest.java b/backend/src/test/java/codezap/template/controller/TemplateControllerTest.java
index 8385134e3..47916dcec 100644
--- a/backend/src/test/java/codezap/template/controller/TemplateControllerTest.java
+++ b/backend/src/test/java/codezap/template/controller/TemplateControllerTest.java
@@ -259,7 +259,7 @@ void findAllTemplatesSuccess() throws Exception {
             FindAllTemplateItemResponse findAllTemplateItemResponse = getFindAllTemplateItemResponse();
 
             when(templateApplicationService.findAllBy(any(), any(), any(), any(), any(), any())).thenReturn(
-                    new FindAllTemplatesResponse(1, 1, List.of(findAllTemplateItemResponse)));
+                    new FindAllTemplatesResponse(1, List.of(findAllTemplateItemResponse)));
 
             // when & then
             mvc.perform(get("/templates")
@@ -267,8 +267,7 @@ void findAllTemplatesSuccess() throws Exception {
                             .contentType(MediaType.APPLICATION_JSON))
                     .andExpect(status().isOk())
                     .andExpect(jsonPath("$.templates.size()").value(1))
-                    .andExpect(jsonPath("$.totalPages").value(1))
-                    .andExpect(jsonPath("$.totalElements").value(1));
+                    .andExpect(jsonPath("$.paginationSizes").value(1));
         }
 
         @Test
@@ -280,7 +279,7 @@ void findAllTemplatesSuccessWhenNoMember() throws Exception {
             when(credentialManager.hasCredential(any())).thenReturn(false);
             when(credentialManager.getCredential(any())).thenReturn(null);
             when(templateApplicationService.findAllBy(any(), any(), any(), any(), any())).thenReturn(
-                    new FindAllTemplatesResponse(1, 1, List.of(findAllTemplateItemResponse)));
+                    new FindAllTemplatesResponse(1, List.of(findAllTemplateItemResponse)));
 
             // when & then
             mvc.perform(get("/templates")
@@ -288,8 +287,7 @@ void findAllTemplatesSuccessWhenNoMember() throws Exception {
                             .contentType(MediaType.APPLICATION_JSON))
                     .andExpect(status().isOk())
                     .andExpect(jsonPath("$.templates.size()").value(1))
-                    .andExpect(jsonPath("$.totalPages").value(1))
-                    .andExpect(jsonPath("$.totalElements").value(1));
+                    .andExpect(jsonPath("$.paginationSizes").value(1));
         }
 
         private FindAllTemplateItemResponse getFindAllTemplateItemResponse() {
@@ -613,14 +611,13 @@ void findTemplateByLiked() throws Exception {
             FindAllTemplateItemResponse findAllTemplateItemResponse = getFindAllTemplateItemResponse(member);
 
             when(templateApplicationService.findAllByLiked(any(), any()))
-                    .thenReturn(new FindAllTemplatesResponse(1, 1, List.of(findAllTemplateItemResponse)));
+                    .thenReturn(new FindAllTemplatesResponse(1, List.of(findAllTemplateItemResponse)));
 
             mvc.perform(get("/templates/like")
                             .contentType(MediaType.APPLICATION_JSON))
                     .andExpect(status().isOk())
                     .andExpect(jsonPath("$.templates.size()").value(1))
-                    .andExpect(jsonPath("$.totalPages").value(1))
-                    .andExpect(jsonPath("$.totalElements").value(1));
+                    .andExpect(jsonPath("$.paginationSizes").value(1));
         }
 
         private FindAllTemplateItemResponse getFindAllTemplateItemResponse(Member member) {
diff --git a/backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java b/backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java
index f4cc03d7d..62af68996 100644
--- a/backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java
+++ b/backend/src/test/java/codezap/template/repository/TemplateRepositoryTest.java
@@ -8,6 +8,7 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
 
 import codezap.category.domain.Category;
 import codezap.category.repository.CategoryRepository;
@@ -15,7 +16,10 @@
 import codezap.fixture.MemberFixture;
 import codezap.fixture.TemplateFixture;
 import codezap.global.exception.CodeZapException;
+import codezap.global.pagination.FixedPage;
 import codezap.global.repository.RepositoryTest;
+import codezap.likes.domain.Likes;
+import codezap.likes.repository.LikesRepository;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.template.domain.Template;
@@ -29,6 +33,8 @@ class TemplateRepositoryTest {
     private MemberRepository memberRepository;
     @Autowired
     private CategoryRepository categoryRepository;
+    @Autowired
+    private LikesRepository likesRepository;
 
     @Test
     @DisplayName("카테고리 id로 템플릿 존재 여부 확인 ")
@@ -91,4 +97,36 @@ void findByMemberIdWhenNotExistsMember() {
             assertThat(templateRepository.findByMemberId(notSavedId)).isEmpty();
         }
     }
+
+    @Nested
+    @DisplayName("회원이 좋아요한 템플릿 조회 테스트")
+    class FindAllByMemberId {
+
+        @Test
+        @DisplayName("성공: 다른 사람의 private은 제외, 내 private은 포함")
+        void findAllByMemberId() {
+            // given
+            Member member = memberRepository.save(MemberFixture.getFirstMember());
+            Member otherMember = memberRepository.save(MemberFixture.getSecondMember());
+
+            Category category = categoryRepository.save(CategoryFixture.get(member));
+            Category otherCategory = categoryRepository.save(CategoryFixture.get(otherMember));
+
+            Template myPublicTemplate = templateRepository.save(TemplateFixture.get(member, category));
+            Template myPrivateTemplate = templateRepository.save(TemplateFixture.getPrivate(member, category));
+            Template otherPublicTemplate = templateRepository.save(TemplateFixture.get(otherMember, otherCategory));
+            Template otherPrivateTemplate = templateRepository.save(TemplateFixture.getPrivate(otherMember, otherCategory));
+
+            likesRepository.save(new Likes(myPublicTemplate, member));
+            likesRepository.save(new Likes(myPrivateTemplate, member));
+            likesRepository.save(new Likes(otherPublicTemplate, member));
+            likesRepository.save(new Likes(otherPrivateTemplate, member));
+
+            // when
+            FixedPage<Template> actual = templateRepository.findAllLikedByMemberId(member.getId(), PageRequest.of(0, 5));
+
+            // then
+            assertThat(actual.contents()).containsExactlyInAnyOrder(myPublicTemplate, myPrivateTemplate, otherPublicTemplate);
+        }
+    }
 }
diff --git a/backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java b/backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java
index b8f4cd086..2552ac60a 100644
--- a/backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java
+++ b/backend/src/test/java/codezap/template/repository/TemplateSearchRepositoryTest.java
@@ -14,7 +14,6 @@
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.FilterType;
 import org.springframework.context.annotation.Import;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Repository;
 import org.springframework.test.context.jdbc.Sql;
@@ -23,9 +22,10 @@
 import codezap.category.domain.Category;
 import codezap.category.repository.CategoryRepository;
 import codezap.global.auditing.JpaAuditingConfiguration;
+import codezap.global.pagination.FixedPage;
+import codezap.global.pagination.FixedPageCounter;
 import codezap.global.querydsl.QueryDSLConfig;
 import codezap.global.rds.DataSourceConfig;
-import codezap.global.repository.RepositoryTest;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.tag.domain.Tag;
@@ -36,12 +36,15 @@
 import codezap.template.repository.strategy.LikeSearchStrategy;
 
 @DataJpaTest(includeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Repository.class), useDefaultFilters = false)
-@Import({JpaAuditingConfiguration.class,
+@Import({
+        JpaAuditingConfiguration.class,
         DataSourceConfig.class,
         QueryDSLConfig.class,
         TemplateSearchExpressionProvider.class,
         LikeSearchStrategy.class,
-        FullTextSearchSearchStrategy.class})
+        FullTextSearchSearchStrategy.class,
+        FixedPageCounter.class,
+})
 @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
 @Sql(scripts = "classpath:search.sql", executionPhase = ExecutionPhase.BEFORE_TEST_CLASS)
 class TemplateSearchRepositoryTest {
@@ -59,7 +62,7 @@ class TemplateSearchRepositoryTest {
     @DisplayName("검색 테스트: 회원 ID로 템플릿 조회 성공")
     void testFindByMemberId() {
         Member member1 = memberRepository.fetchById(1L);
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 member1.getId(),
                 null,
                 null,
@@ -68,8 +71,8 @@ void testFindByMemberId() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent()).hasSize(2),
-                () -> assertThat(result.getContent())
+                () -> assertThat(result.contents()).hasSize(2),
+                () -> assertThat(result.contents())
                         .allMatch(template -> template.getMember().getId().equals(member1.getId()))
         );
     }
@@ -78,7 +81,7 @@ void testFindByMemberId() {
     @DisplayName("검색 테스트: 키워드로 템플릿 조회 성공")
     void testFindByKeyword() {
         String keyword = "Template";
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 null,
                 keyword,
                 null,
@@ -87,10 +90,10 @@ void testFindByKeyword() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent())
+                () -> assertThat(result.contents())
                         .allMatch(template -> template.getTitle().contains(keyword)
                                 || template.getDescription().contains(keyword)),
-                () -> assertThat(result.getContent()).hasSize(4)
+                () -> assertThat(result.contents()).hasSize(4)
         );
     }
 
@@ -98,7 +101,7 @@ void testFindByKeyword() {
     @DisplayName("검색 테스트: 카테고리 ID로 템플릿 조회 성공")
     void testFindByCategoryId() {
         Category category1 = categoryRepository.fetchById(1L);
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 null,
                 null,
                 category1.getId(),
@@ -107,8 +110,8 @@ void testFindByCategoryId() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent()).hasSize(2),
-                () -> assertThat(result.getContent())
+                () -> assertThat(result.contents()).hasSize(2),
+                () -> assertThat(result.contents())
                         .allMatch(template -> template.getCategory().getId().equals(category1.getId()))
         );
     }
@@ -119,7 +122,7 @@ void testFindByTagIds() {
         Tag tag1 = tagRepository.fetchById(1L);
         Tag tag2 = tagRepository.fetchById(2L);
         List<Long> tagIds = Arrays.asList(tag1.getId(), tag2.getId());
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 null,
                 null,
                 null,
@@ -128,12 +131,12 @@ void testFindByTagIds() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent())
+                () -> assertThat(result.contents())
                         .containsExactlyInAnyOrder(
                                 templateRepository.fetchById(1L),
                                 templateRepository.fetchById(2L),
                                 templateRepository.fetchById(3L)),
-                () -> assertThat(result.getContent()).hasSize(3)
+                () -> assertThat(result.contents()).hasSize(3)
         );
     }
 
@@ -142,7 +145,7 @@ void testFindByTagIds() {
     void testFindBySingleTagId() {
         Tag tag2 = tagRepository.fetchById(2L);
         List<Long> tagIds = List.of(tag2.getId());
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 null,
                 null,
                 null,
@@ -151,19 +154,19 @@ void testFindBySingleTagId() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent())
+                () -> assertThat(result.contents())
                         .containsExactlyInAnyOrder(
                                 templateRepository.fetchById(1L),
                                 templateRepository.fetchById(2L),
                                 templateRepository.fetchById(3L)),
-                () -> assertThat(result.getContent()).hasSize(3)
+                () -> assertThat(result.contents()).hasSize(3)
         );
     }
 
     @Test
     @DisplayName("검색 테스트: 공개 범위로 템플릿 조회 성공")
     void testFindByVisibility() {
-        Page<Template> actual = templateRepository.findAll(
+        FixedPage<Template> actual = templateRepository.findAll(
                 null,
                 null,
                 null,
@@ -171,7 +174,7 @@ void testFindByVisibility() {
                 Visibility.PRIVATE,
                 PageRequest.of(0, 10));
 
-        assertThat(actual.getContent()).hasSize(1)
+        assertThat(actual.contents()).hasSize(1)
                 .containsExactlyInAnyOrder(templateRepository.fetchById(4L));
     }
 
@@ -180,7 +183,7 @@ void testFindByVisibility() {
     void testFindByMemberIdAndKeyword() {
         Member member1 = memberRepository.fetchById(1L);
         String keyword = "Template";
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 member1.getId(),
                 keyword,
                 null,
@@ -189,8 +192,8 @@ void testFindByMemberIdAndKeyword() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent()).hasSize(2),
-                () -> assertThat(result.getContent())
+                () -> assertThat(result.contents()).hasSize(2),
+                () -> assertThat(result.contents())
                         .allMatch(template -> template.getMember().getId().equals(member1.getId())
                                 && (template.getTitle().contains(keyword)
                                 || template.getDescription().contains(keyword)))
@@ -202,7 +205,7 @@ void testFindByMemberIdAndKeyword() {
     void testFindByMemberIdAndCategoryId() {
         Member member1 = memberRepository.fetchById(1L);
         Category category1 = categoryRepository.fetchById(1L);
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 member1.getId(),
                 null,
                 category1.getId(),
@@ -211,9 +214,9 @@ void testFindByMemberIdAndCategoryId() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent()).hasSize(1),
-                () -> assertThat(result.getContent().get(0).getMember().getId()).isEqualTo(member1.getId()),
-                () -> assertThat(result.getContent().get(0).getCategory().getId()).isEqualTo(category1.getId())
+                () -> assertThat(result.contents()).hasSize(1),
+                () -> assertThat(result.contents().get(0).getMember().getId()).isEqualTo(member1.getId()),
+                () -> assertThat(result.contents().get(0).getCategory().getId()).isEqualTo(category1.getId())
         );
     }
 
@@ -224,7 +227,7 @@ void testFindByMemberIdAndTagIds() {
         Tag tag1 = tagRepository.fetchById(1L);
         Tag tag2 = tagRepository.fetchById(2L);
         List<Long> tagIds = Arrays.asList(tag1.getId(), tag2.getId());
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 member1.getId(),
                 null,
                 null,
@@ -233,8 +236,8 @@ void testFindByMemberIdAndTagIds() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent()).hasSize(2),
-                () -> assertThat(result.getContent()).containsExactlyInAnyOrder(templateRepository.fetchById(1L),
+                () -> assertThat(result.contents()).hasSize(2),
+                () -> assertThat(result.contents()).containsExactlyInAnyOrder(templateRepository.fetchById(1L),
                         templateRepository.fetchById(2L))
         );
     }
@@ -243,7 +246,7 @@ void testFindByMemberIdAndTagIds() {
     @DisplayName("검색 테스트: 회원 ID와 공개 범위로 템플릿 조회 성공")
     void testFindByMemberIdAndVisibility() {
         Member member1 = memberRepository.fetchById(2L);
-        Page<Template> actual = templateRepository.findAll(
+        FixedPage<Template> actual = templateRepository.findAll(
                 member1.getId(),
                 null,
                 null,
@@ -251,7 +254,7 @@ void testFindByMemberIdAndVisibility() {
                 Visibility.PUBLIC,
                 PageRequest.of(0, 10));
 
-        assertThat(actual.getContent()).hasSize(1)
+        assertThat(actual.contents()).hasSize(1)
                 .containsExactlyInAnyOrder(templateRepository.fetchById(3L));
     }
 
@@ -264,7 +267,7 @@ void testFindWithAllCriteria() {
         Tag tag2 = tagRepository.fetchById(2L);
         String keyword = "Template";
         List<Long> tagIds = Arrays.asList(tag1.getId(), tag2.getId());
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 member1.getId(),
                 keyword,
                 category1.getId(),
@@ -273,15 +276,15 @@ void testFindWithAllCriteria() {
                 PageRequest.of(0, 10));
 
         assertAll(
-                () -> assertThat(result.getContent()).hasSize(1),
-                () -> assertThat(result.getContent()).containsExactlyInAnyOrder(templateRepository.fetchById(1L))
+                () -> assertThat(result.contents()).hasSize(1),
+                () -> assertThat(result.contents()).containsExactlyInAnyOrder(templateRepository.fetchById(1L))
         );
     }
 
     @Test
     @DisplayName("검색 테스트: 검색 결과가 없는 경우 빈 리스트 반환 성공")
     void testFindWithNoResults() {
-        Page<Template> result = templateRepository.findAll(
+        FixedPage<Template> result = templateRepository.findAll(
                 null,
                 "없지롱",
                 null,
@@ -289,6 +292,6 @@ void testFindWithNoResults() {
                 null,
                 PageRequest.of(0, 10));
 
-        assertThat(result.getContent()).isEmpty();
+        assertThat(result.contents()).isEmpty();
     }
 }
diff --git a/backend/src/test/java/codezap/template/service/TemplateSearchServiceTest.java b/backend/src/test/java/codezap/template/service/TemplateSearchServiceTest.java
index cff96293c..12237b7ae 100644
--- a/backend/src/test/java/codezap/template/service/TemplateSearchServiceTest.java
+++ b/backend/src/test/java/codezap/template/service/TemplateSearchServiceTest.java
@@ -13,7 +13,6 @@
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 
@@ -23,6 +22,7 @@
 import codezap.fixture.TemplateFixture;
 import codezap.global.DatabaseIsolation;
 import codezap.global.exception.CodeZapException;
+import codezap.global.pagination.FixedPage;
 import codezap.member.domain.Member;
 import codezap.member.repository.MemberRepository;
 import codezap.tag.domain.Tag;
@@ -103,9 +103,9 @@ void findAllSuccessByMemberId() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getMember().getId().equals(member1.getId()))
                     .toArray(Template[]::new));
         }
@@ -136,9 +136,9 @@ void findAllSuccessByKeyword() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getTitle().contains(keyword) || template.getDescription().contains(keyword))
                     .toArray(Template[]::new));
         }
@@ -153,9 +153,9 @@ void findAllSuccessByCategoryId() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getCategory().getId().equals(category1.getId()))
                     .toArray(Template[]::new));
         }
@@ -170,15 +170,15 @@ void findAllSuccessByTagIds() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
             assertAll(
-                    () -> assertThat(actual.getContent())
+                    () -> assertThat(actual.contents())
                             .containsExactlyInAnyOrder(
                                     templateRepository.fetchById(1L),
                                     templateRepository.fetchById(2L),
                                     templateRepository.fetchById(3L)),
-                    () -> assertThat(actual.getContent()).hasSize(3)
+                    () -> assertThat(actual.contents()).hasSize(3)
             );
         }
 
@@ -192,14 +192,14 @@ void findAllSuccessBySingleTagId() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
             assertAll(
-                    () -> assertThat(actual.getContent()).containsExactlyInAnyOrder(
+                    () -> assertThat(actual.contents()).containsExactlyInAnyOrder(
                             templateRepository.fetchById(1L),
                             templateRepository.fetchById(2L),
                             templateRepository.fetchById(3L)),
-                    () -> assertThat(actual.getContent()).hasSize(3)
+                    () -> assertThat(actual.contents()).hasSize(3)
             );
         }
 
@@ -213,9 +213,9 @@ void findAllSuccessByVisibility() {
             Visibility visibility = Visibility.PUBLIC;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getVisibility().equals(visibility))
                     .toArray(Template[]::new));
         }
@@ -230,9 +230,9 @@ void findAllSuccessByMemberIdAndKeyword() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getMember().getId().equals(member1.getId())
                             && (template.getTitle().contains(keyword) || template.getDescription().contains(keyword)))
                     .toArray(Template[]::new));
@@ -248,9 +248,9 @@ void findAllSuccessByMemberIdAndCategoryId() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getMember().getId().equals(member1.getId()) && template.getCategory()
                             .getId().equals(category1.getId()))
                     .toArray(Template[]::new));
@@ -266,11 +266,11 @@ void findAllSuccessByMemberIdAndTagIds() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
             assertAll(
-                    () -> assertThat(actual.getContent()).hasSize(2),
-                    () -> assertThat(actual.getContent())
+                    () -> assertThat(actual.contents()).hasSize(2),
+                    () -> assertThat(actual.contents())
                             .containsExactlyInAnyOrder(
                                     templateRepository.fetchById(1L),
                                     templateRepository.fetchById(2L))
@@ -287,9 +287,9 @@ void findAllSuccessByMemberIdAndVisibility() {
             Visibility visibility = Visibility.PUBLIC;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).containsExactlyInAnyOrder(templates.stream()
+            assertThat(actual.contents()).containsExactlyInAnyOrder(templates.stream()
                     .filter(template -> template.getMember().getId().equals(member2.getId())
                             && template.getVisibility().equals(visibility))
                     .toArray(Template[]::new));
@@ -305,11 +305,11 @@ void findAllSuccessWithAllCriteria() {
             Visibility visibility = Visibility.PUBLIC;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
             assertAll(
-                    () -> assertThat(actual.getContent()).hasSize(1),
-                    () -> assertThat(actual.getContent()).containsExactlyInAnyOrder(templateRepository.fetchById(1L))
+                    () -> assertThat(actual.contents()).hasSize(1),
+                    () -> assertThat(actual.contents()).containsExactlyInAnyOrder(templateRepository.fetchById(1L))
             );
         }
 
@@ -323,9 +323,9 @@ void findAllSuccessWithNoResults() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(0, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
-            assertThat(actual.getContent()).isEmpty();
+            assertThat(actual.contents()).isEmpty();
         }
     }
 
@@ -352,14 +352,13 @@ void findAllSuccessWithSecondPage() {
             Visibility visibility = null;
             Pageable pageable = PageRequest.of(1, 10);
 
-            Page<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
+            FixedPage<Template> actual = sut.findAllBy(memberId, keyword, categoryId, tagIds, visibility, pageable);
 
             assertAll(
-                    () -> assertThat(actual.getContent()).hasSize(5),
-                    () -> assertThat(actual.getContent().get(0).getId()).isEqualTo(11L)
+                    () -> assertThat(actual.contents()).hasSize(5),
+                    () -> assertThat(actual.contents().get(0).getId()).isEqualTo(11L)
             );
         }
-
     }
 
     private void saveInitialData() {
diff --git a/backend/src/test/java/codezap/template/service/TemplateServiceTest.java b/backend/src/test/java/codezap/template/service/TemplateServiceTest.java
index db1f55716..9c21c1dab 100644
--- a/backend/src/test/java/codezap/template/service/TemplateServiceTest.java
+++ b/backend/src/test/java/codezap/template/service/TemplateServiceTest.java
@@ -10,7 +10,6 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Sort.Direction;
@@ -21,6 +20,8 @@
 import codezap.fixture.TemplateFixture;
 import codezap.global.ServiceTest;
 import codezap.global.exception.CodeZapException;
+import codezap.global.pagination.FixedPage;
+import codezap.likes.domain.Likes;
 import codezap.likes.service.LikesService;
 import codezap.member.domain.Member;
 import codezap.template.domain.Template;
@@ -155,7 +156,7 @@ void sortByLikesCount() {
 
             List<Template> templates = sut.findAllBy(null, "", null, null, null,
                             PageRequest.of(0, 10, Sort.by(Direction.DESC, "likesCount")))
-                    .getContent();
+                    .contents();
 
             assertThat(templates).containsExactly(
                     templateRepository.fetchById(3L),
@@ -190,6 +191,34 @@ private void likeTemplate(long templateId, long likesCount) {
         }
     }
 
+
+    @Nested
+    @DisplayName("좋아요한 템플릿 조회")
+    class FindAllByMemberId {
+
+        @Test
+        @DisplayName("성공")
+        void findAllByMemberId() {
+            // given
+            Member member1 = memberRepository.save(MemberFixture.getFirstMember());
+            Member member2 = memberRepository.save(MemberFixture.getSecondMember());
+            Category category1 = categoryRepository.save(CategoryFixture.get(member1));
+            Category category2 = categoryRepository.save(CategoryFixture.get(member2));
+            Template template1 = templateRepository.save(TemplateFixture.get(member1, category1));
+            Template template2 = templateRepository.save(TemplateFixture.get(member1, category1));
+            Template template3 = templateRepository.save(TemplateFixture.get(member2, category2));
+            likesRepository.save(new Likes(template1, member1));
+            likesRepository.save(new Likes(template2, member2));
+            likesRepository.save(new Likes(template3, member1));
+
+            // when
+            FixedPage<Template> actual = templateRepository.findAllLikedByMemberId(member1.getId(), PageRequest.of(0, 5));
+
+            // then
+            assertThat(actual.contents()).containsExactlyInAnyOrder(template1, template3);
+        }
+    }
+
     @Nested
     @DisplayName("템플릿 수정")
     class UpdateTemplate {
@@ -278,10 +307,10 @@ void deleteTemplateSuccessWithOneTemplate() {
             var template2 = templateRepository.save(TemplateFixture.get(member, category));
 
             sut.deleteByMemberAndIds(member, List.of(template1.getId()));
-            Page<Template> actual = sut.findAllBy(member.getId(), null, null, null, null,
+            FixedPage<Template> actual = sut.findAllBy(member.getId(), null, null, null, null,
                     PageRequest.of(0, 10));
 
-            assertThat(actual.getContent()).hasSize(1)
+            assertThat(actual.contents()).hasSize(1)
                     .containsExactly(template2);
         }
 
@@ -296,10 +325,10 @@ void deleteTemplateSuccessWithMultipleTemplate() {
             var template4 = templateRepository.save(TemplateFixture.get(member, category));
 
             sut.deleteByMemberAndIds(member, List.of(template1.getId(), template4.getId()));
-            Page<Template> actual = sut.findAllBy(member.getId(), null, null, null, null,
+            FixedPage<Template> actual = sut.findAllBy(member.getId(), null, null, null, null,
                     PageRequest.of(0, 10));
 
-            assertThat(actual.getContent()).hasSize(2)
+            assertThat(actual.contents()).hasSize(2)
                     .containsExactly(template2, template3);
         }
 
diff --git a/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java b/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java
index 724277779..23efa6d32 100644
--- a/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java
+++ b/backend/src/test/java/codezap/template/service/facade/TemplateApplicationServiceTest.java
@@ -530,8 +530,8 @@ void deleteByMemberAndIds() {
             actualSourceCodeLeft.addAll(sourceCodeRepository.findAllByTemplate(template3));
 
             assertAll(
-                    () -> assertThat(actualTemplatesLeft).containsExactly(template3),
-                    () -> assertThat(actualTemplatesLeft).doesNotContain(template1, template2),
+                    () -> assertThat(actualTemplatesLeft.contents()).containsExactly(template3),
+                    () -> assertThat(actualTemplatesLeft.contents()).doesNotContain(template1, template2),
                     () -> assertThat(actualSourceCodeLeft).containsExactly(sourceCode3),
                     () -> assertThat(actualSourceCodeLeft).doesNotContain(sourceCode1, sourceCode2)
             );
diff --git a/backend/src/test/resources/search.sql b/backend/src/test/resources/search.sql
index 4d40511cb..217f75964 100644
--- a/backend/src/test/resources/search.sql
+++ b/backend/src/test/resources/search.sql
@@ -15,6 +15,9 @@ VALUES (1, '2024-09-27 08:43:08.752936', '2024-09-27 08:43:08.752936', '몰리',
 INSERT INTO member (id, created_at, modified_at, name, password, salt)
 VALUES (2, '2024-09-27 08:43:08.757482', '2024-09-27 08:43:08.757482', '몰리2', 'password1234', 'salt2');
 
+INSERT INTO member (id, created_at, modified_at, name, password, salt)
+VALUES (3, '2024-09-27 08:43:08.757482', '2024-09-27 08:43:08.757482', '몰리3', 'password1234', 'salt2');
+
 -- Category 삽입
 INSERT INTO category (id, created_at, is_default, member_id, modified_at, name)
 VALUES (1, '2024-09-27 08:43:08.760511', false, 1, '2024-09-27 08:43:08.760511', 'Category 1');
@@ -42,6 +45,16 @@ VALUES (3, 1, '2024-09-27 08:43:08.790778', 'Description 1', 2, '2024-09-27 08:4
 INSERT INTO template (id, category_id, created_at, description, member_id, modified_at, title, visibility)
 VALUES (4, 2, '2024-09-27 08:43:08.790780', 'Description 1', 2, '2024-09-27 08:43:08.790780', 'Template 1', 'PRIVATE');
 
+INSERT INTO template (id, category_id, created_at, description, member_id, modified_at, title, visibility)
+VALUES (5, 2, '2024-09-27 08:43:08.790780', 'Description 1', 3, '2024-09-27 08:43:08.790780', '템플릿1', 'PUBLIC');
+
+INSERT INTO template (id, category_id, created_at, description, member_id, modified_at, title, visibility)
+VALUES (6, 2, '2024-09-27 08:43:08.790780', 'Description 1', 3, '2024-09-27 08:43:08.790780', '템플릿2', 'PUBLIC');
+
+INSERT INTO template (id, category_id, created_at, description, member_id, modified_at, title, visibility)
+VALUES (7, 2, '2024-09-27 08:43:08.790780', 'Description 1', 3, '2024-09-27 08:43:08.790780', '템플릿3', 'PUBLIC');
+
+
 -- Source Code 삽입
 INSERT INTO source_code (id, content, created_at, filename, modified_at, ordinal, template_id)
 VALUES (1, 'content1', '2024-09-27 08:43:08.793152', 'filename1', '2024-09-27 08:43:08.793152', 1, 1);
@@ -90,7 +103,7 @@ WHERE table_name = 'template'
   AND index_name = 'idx_template_fulltext';
 
 -- 없다면 전문 검색 인덱스 생성
-SET @createIndex = IF(@indexExists = 0, 'CREATE FULLTEXT INDEX idx_template_fulltext ON template (title, description);', 'SELECT 1');
+SET @createIndex = IF(@indexExists = 0, 'CREATE FULLTEXT INDEX idx_template_fulltext ON template (title, description) with parser ngram;', 'SELECT 1');
 PREPARE stmt FROM @createIndex;
 EXECUTE stmt;
 DEALLOCATE PREPARE stmt;

From 0b4fcdaf9bb3e2201947967287f9162973806270 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=A0=95=ED=9A=8C=EC=84=B1?= <ghltjd3@gmail.com>
Date: Fri, 15 Nov 2024 21:36:56 +0900
Subject: [PATCH 8/8] =?UTF-8?q?=EC=BD=98=EC=86=94=20=EB=A1=9C=EA=B7=B8=20?=
 =?UTF-8?q?=ED=95=98=EC=9D=B4=EB=9D=BC=EC=9D=B4=ED=8C=85=20(#914)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../resources/logger/console/console-appender.xml     | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/backend/src/main/resources/logger/console/console-appender.xml b/backend/src/main/resources/logger/console/console-appender.xml
index ee5834005..09bf77425 100644
--- a/backend/src/main/resources/logger/console/console-appender.xml
+++ b/backend/src/main/resources/logger/console/console-appender.xml
@@ -1,12 +1,9 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<configuration>
+
+<included>
     <appender name="console-appender" class="ch.qos.logback.core.ConsoleAppender">
         <layout class="ch.qos.logback.classic.PatternLayout">
-            <pattern>[%level][%d{MM-dd HH:mm:ss}][%X{correlationId}][%logger{20}] %msg%n</pattern>
+            <pattern>[%highlight(%level)][%d{MM-dd HH:mm:ss}][%magenta(%8X{correlationId})][%highlight(%replace(%logger{20}){'\\w\\.', ''})] %msg %n</pattern>
         </layout>
     </appender>
-
-    <root level="INFO">
-        <appender-ref ref="console-appender" />
-    </root>
-</configuration>
+</included>