@RunWith(SpringRunner.class)
@DataJpaTest
public class PostRepositoryTest {
    @Autowired
    private PostRepository postRepository;

    @Test
    @Rollback(false)
    public void crudRepository() {
        // Given
        Post post = new Post();
        post.setTitle("hello spring common");
        assertThat(post.getId()).isNull();

        // When
        Post newPost = postRepository.save(post);

        // Then
        assertThat(newPost.getId()).isNotNull();

        // When JPA Repository method
        List<Post> posts = postRepository.findAll();

        // Then
        assertThat(posts.size()).isEqualTo(1);
        assertThat(posts).contains(newPost);

        // When
        Page<Post> page = postRepository.findAll(PageRequest.of(0, 10));
        assertThat(page.getTotalElements()).isEqualTo(1);
        assertThat(page.getNumber()).isEqualTo(0);
        assertThat(page.getSize()).isEqualTo(10);
    }
}

// interface
@NoRepositoryBean
public interface MyRepository<T, Id extends Serializable> extends Repository<T, Id> {
    <E extends T> E save(@NonNull E entity);

    List<T> findAll();

    long count();

    @Nullable
    <E extends T>Optional<E> findById(Id id);
}
// repository
public interface CommentRepository extends MyRepository<Comment, Long> {
}
//Test
@RunWith(SpringRunner.class)
@DataJpaTest
public class CommentRepositoryTest {

    @Autowired
    private CommentRepository commentRepository;

    @Test
    public void crudTest() {
        Comment comment = new Comment();
        comment.setComment("Hello Comment");
        commentRepository.save(comment);

        List<Comment> all = commentRepository.findAll();
        assertThat(all.size()).isEqualTo(1);
    }
}

public interface CommentRepository extends MyRepository<Comment, Long> {

    @Query(value = "SELECT c FROM Comment AS c", nativeQuery = true) // case2
    List<Comment> findByTitleContains(String keyword); // case1
}

public @interface EnableJpaRepositories {
	Key queryLookupStrategy() default Key.CREATE_IF_NOT_FOUND;
}

public interface QueryLookupStrategy {
	RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
			NamedQueries namedQueries);
}

public interface PostCustomRepository {
    List<Post> findMyPost();
}

public class PostCustomRepositoryImpl implements PostCustomRepository {
    @Autowired
    private EntityManager entityManager;

    @Override
    public List<Post> findMyPost() {
        System.out.println("custom findMyPost");
        return entityManager.createQuery("SELECT p from Post AS p", Post.class)
                .getResultList();
    }
}

public interface PostRepository extends JpaRepository<Post, Long>, PostCustomRepository {
}

//JpaRepository의 구현체인 SimpleJpaRepository의코드
@Transactional
	public void delete(T entity) {

		Assert.notNull(entity, "The entity must not be null!");
		em.remove(em.contains(entity) ? entity : em.merge(entity));
	}

// 인터페이스에 추가
public interface PostCustomRepository<T> {
    List<Post> findMyPost();
    void delete(T entity);
}

// delete 재정의
public class PostCustomRepositoryImpl implements PostCustomRepository {
    @Override
    public void delete(Object entity) {
        System.out.println("custom delete");
        entityManager.remove(entity);
    }
}

//Test
@Test
public void customRepository() {
    Post post = new Post();
    post.setTitle("hibernate");
    postRepository.save(post);
  	postRepository.findMyPost(); // case2
    postRepository.delete(post);
  	postRepository.flush(); // case3. delete가 출력된다.
}

// step1
@NoRepositoryBean
public interface CommonRepository<T, ID> extends JpaRepository<T, ID> {
    boolean contains(T entity);
}

// step2
public class CommonRepositoryImpl<T, ID extends Serializable> extends SimpleJpaRepository<T, ID> implements CommonRepository<T, ID> {
    private EntityManager entityManager;
    public CommonRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
        super(entityInformation, entityManager);
        this.entityManager = entityManager;
    }
    @Override
    public boolean contains(T entity) {
        return entityManager.contains(entity);
    }
}

// step3
@EnableJpaRepositories(repositoryBaseClass = CommonRepositoryImpl.class)

// step4
public interface PostRepository extends CommonRepository<Post, Long> {
}

// 기존의 방식
// 이벤트 퍼블리셔
public class PostPublishedEvent extends ApplicationEvent {

    private final Post post;
    /**
     * Create a new ApplicationEvent.
     *
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public PostPublishedEvent(Object source) {
        super(source);
        this.post = (Post)source;
    }

    public Post getPost() {
        return post;
    }
}

// 리스너
public class PostListener implements ApplicationListener<PostPublishedEvent> {
    @Override
    public void onApplicationEvent(PostPublishedEvent event) {
        System.out.println("------");
        System.out.println(event.getPost().getTitle() + " post published");
        System.out.println("------");
    }
}

// 설정빈
@Configuration
public class PostRepositoryConfig {
    @Bean
    public PostListener postListener() {
        return new PostListener();
    }
}

// 테스트코드
@RunWith(SpringRunner.class)
@DataJpaTest
@Import(PostRepositoryConfig.class)
public class DomainPublishTest {
    @Autowired
    ApplicationContext applicationContext;

    @Test
    public void event() {
        Post post = new Post();
        post.setTitle("event");
        PostPublishedEvent event = new PostPublishedEvent(post);

        applicationContext.publishEvent(event);
    }
}

// 방법1
public class PostListener {
    @EventListener
    public void onApplicationEvent(PostPublishedEvent event) {
        System.out.println("------");
        System.out.println(event.getPost().getTitle() + " post published");
        System.out.println("------");
    }
}

// 방법2
@Configuration
public class PostRepositoryConfig {
    @Bean
    public ApplicationListener<PostPublishedEvent> postListener() {
        return event -> {
            System.out.println("------------------------");
            System.out.println(event.getPost().getTitle() + " is publishedEvenet");
            System.out.println("------------------------");
        };
    }
}

public class AbstractAggregateRoot<A extends AbstractAggregateRoot<A>> {
	private transient final @Transient List<Object> domainEvents = new ArrayList<>();
	/**
	 * Registers the given event object for publication on a call to a Spring Data repository's save methods.
	 *
	 * @param event must not be {@literal null}.
	 * @return the event that has been added.
	 * @see #andEvent(Object)
	 */
	protected <T> T registerEvent(T event) {
		Assert.notNull(event, "Domain event must not be null!");
		this.domainEvents.add(event);
		return event;
	}
	/**
	 * Clears all domain events currently held. Usually invoked by the infrastructure in place in Spring Data
	 * repositories.
	 */
	@AfterDomainEventPublication
	protected void clearDomainEvents() {
		this.domainEvents.clear();
	}
	/**
	 * All domain events currently captured by the aggregate.
	 */
	@DomainEvents
	protected Collection<Object> domainEvents() {
		return Collections.unmodifiableList(domainEvents);
	}
	.....
}

public interface AccountRepository extends JpaRepository<Account, Long>, QuerydslPredicateExecutor<Account> {
}

@Entity
public class Account {
    @Id @GeneratedValue
    private Long id;
    private String firstName;
    private String lastName;
		....
}

@DataJpaTest
@RunWith(SpringRunner.class)
public class AccountTest {
    @Autowired
    private AccountRepository accountRepository;
    @Test
    public void crud() {
        QAccount account = QAccount.account;
        Predicate predicate = account
                .firstName.containsIgnoreCase("jimmy")
                .and(account.lastName.startsWith("kim"));
        Optional<Account> one = accountRepository.findOne(predicate);
        assertThat(one).isEmpty();
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class PostControllerTest {
  @Test
    public void getPost() throws Exception {
        Post post = new Post();
        post.setTitle("mock");
        postRepository.save(post);

        mockMvc.perform(get("/posts/" + post.getId()))
                .andDo(print())
                .andExpect(status().isOk())
                .andExpect(content().string("mock"));
    }
}

@GetMapping("/posts/{id}")
    public String getPost(@PathVariable("id") Post post) {
        return post.getTitle();
    }

@GetMapping("/posts")
    public Page<Post> getPosts(Pageable pageable) {
        return postRepository.findAll(pageable);
    }

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
@ActiveProfiles("test")
public class PostControllerTest {
    @Autowired
    MockMvc mockMvc;

    @Autowired
    private PostRepository postRepository;

    @Test
    public void getPosts() throws Exception {
        Post post = new Post();
        post.setTitle("mock");
        postRepository.save(post);

        mockMvc.perform(get("/posts/")
                .param("page", "0")
                .param("size","10")
                .param("sort","created,desc")
                .param("sort","title"))
                .andDo(print())
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.content[0].title", is("mock")));
    }
}

@GetMapping("/posts")
    public PagedModel<EntityModel<Post>> getPosts(Pageable pageable, PagedResourcesAssembler<Post> assembler) {
        Page<Post> all = postRepository.findAll(pageable);
        return assembler.toModel(all);
    }