This document contains various Korean text fragments discussing topics like a developer event, work as a gardener, missions or tasks, databases, SDKs, and deploying code. It appears to be notes from several different conversations or sources touching on software development, but the individual passages are not clearly connected to each other.
This document discusses JPQL join fetch queries in JPA. It explains that join fetch queries can result in a cartesian product between tables if not written properly. It provides examples of order, member, and delivery entities to illustrate this issue. It also discusses using the distinct keyword in JPQL queries, clarifying that distinct applies to root entities, not rows in the SQL query. Finally, it mentions that fetch joins can be optimized using batch fetching.
This document discusses JPA value types and the Command Query Responsibility Segregation (CQRS) pattern with case studies. It covers JPA entity types, basic types, embedded types, and collection types. CQRS separates read and write operations by using different models for commands and queries. Case studies demonstrate how CQRS was implemented at companies to improve performance and scalability, such as handling 15,000 transactions per second. Links are provided to additional resources on embedded types, subquery joins, and CQRS case studies.
1. The document discusses test-driven development (TDD) and how to use it with JPA and MockMVC for testing database operations and web service endpoints.
2. It provides examples of writing TDD tests for simple math operations and outlines some benefits and challenges of the TDD approach.
3. Resources and case studies are referenced on best practices for applying TDD, MockMVC, and JPA testing in real projects.
1. The document discusses writing test code and outlines a multi-week plan for learning testing techniques like JPA, ORM, TDD, DDD, and MVC.
2. It recommends practices like using Mockito to mock dependencies, avoiding unnecessary mocking, and following FIRST principles of tests being fast, independent, repeatable, self-validating, and timely.
3. The document also provides resources on functional decomposition, abstract data types, object-oriented design, and troubleshooting services.
JPA Week3 Entity Mapping / Hexagonal ArchitectureCovenant Ko
The document discusses Hexagonal Architecture and its principles. It explains that the core domain layer should not depend on other layers like the data layer. It provides examples of package structures for Hexagonal Architecture and sample code that separates ports and adapters. Case studies are presented on how companies have implemented Hexagonal Architecture for microservices and APIs.
This document contains various Korean text fragments discussing topics like a developer event, work as a gardener, missions or tasks, databases, SDKs, and deploying code. It appears to be notes from several different conversations or sources touching on software development, but the individual passages are not clearly connected to each other.
This document discusses JPQL join fetch queries in JPA. It explains that join fetch queries can result in a cartesian product between tables if not written properly. It provides examples of order, member, and delivery entities to illustrate this issue. It also discusses using the distinct keyword in JPQL queries, clarifying that distinct applies to root entities, not rows in the SQL query. Finally, it mentions that fetch joins can be optimized using batch fetching.
This document discusses JPA value types and the Command Query Responsibility Segregation (CQRS) pattern with case studies. It covers JPA entity types, basic types, embedded types, and collection types. CQRS separates read and write operations by using different models for commands and queries. Case studies demonstrate how CQRS was implemented at companies to improve performance and scalability, such as handling 15,000 transactions per second. Links are provided to additional resources on embedded types, subquery joins, and CQRS case studies.
1. The document discusses test-driven development (TDD) and how to use it with JPA and MockMVC for testing database operations and web service endpoints.
2. It provides examples of writing TDD tests for simple math operations and outlines some benefits and challenges of the TDD approach.
3. Resources and case studies are referenced on best practices for applying TDD, MockMVC, and JPA testing in real projects.
1. The document discusses writing test code and outlines a multi-week plan for learning testing techniques like JPA, ORM, TDD, DDD, and MVC.
2. It recommends practices like using Mockito to mock dependencies, avoiding unnecessary mocking, and following FIRST principles of tests being fast, independent, repeatable, self-validating, and timely.
3. The document also provides resources on functional decomposition, abstract data types, object-oriented design, and troubleshooting services.
JPA Week3 Entity Mapping / Hexagonal ArchitectureCovenant Ko
The document discusses Hexagonal Architecture and its principles. It explains that the core domain layer should not depend on other layers like the data layer. It provides examples of package structures for Hexagonal Architecture and sample code that separates ports and adapters. Case studies are presented on how companies have implemented Hexagonal Architecture for microservices and APIs.
JPA 스터디 Week2 - Object Relational MappingCovenant Ko
This document discusses Object-Relational Mapping (ORM) and JPA. It begins with an introduction to the author and their background and credentials. It then poses some questions about ORM and defines it as mapping between object-oriented programming languages and relational databases. It discusses some of the challenges with ORM including differences in granularity, inheritance, identity, associations, and data navigation between objects and relational databases. It also covers ORM patterns like Active Record and Data Mapper and compares JPA, Hibernate, and Spring Data JPA. Finally, it provides a case study example of applying ORM and architectural patterns to an online ordering system.
This document contains information about Covenant Ko, including his background and links to his Github and blog. It discusses ORM and JPA, with JPA standing for Java Persistence API. It includes a pop quiz question asking about the relationships between ORM, JPA, and JPA providers like Hibernate. The document also references a case study on using Hazelcast for Hibernate second-level caching to improve performance.
This document contains notes from Covenant Ko on software design patterns and principles. It discusses functional decomposition, abstract data types, and object-oriented programming. It covers topics like the differences between assembling and composing code, open-closed and quality assurance principles, and relationships between abstract data types and objects. Links are provided to external references and resources on these topics.
The document discusses Covenant Ko and chapter 5. It mentions Covenant Ko's name and company (11번가) and links to his Github and tech blog. It then covers the GRASP pattern for software design, including information expert, controller and other patterns. It discusses the need for responsibility-driven design and applying the GRASP patterns.
- Covenant Ko is a founder and maintainer of the Github organization 'brave-people' and has a technical blog that has received over 410,000 visits
- He explains Anderson's Formula for calculating expected value, which takes into account probability of success (P) and payoff for success (S)
- Some tips he provides include making the common case fast, using static fields for caches but not databases, and that StringBuffer is thread-safe while StringBuilder is not
This chapter discusses Covenant Ko, who works at 11번가 and is the founder and maintainer of the Github organization '용감한친구들'. It also contains Ko's Github profile and tech blog. The chapter then discusses some problems around separation of concerns, propagation of changes, and cycle references. It questions where logic for finding linked or registered accounts should be placed. It introduces the concept of abstract data types and developing object-oriented applications based on this concept. It also mentions model-view separation in application development.
The document discusses the life cycle of Spring beans. It begins with an overview of how beans are defined using XML, stereotype annotations, and configuration. It then covers the key stages in the bean life cycle: 1) Context loading where the configuration is merged and validated, 2) Dependency injection where dependencies are injected either through constructors, setters or fields, and 3) A pop quiz about the final bean definition and how it can be modified through a BeanFactoryPostProcessor.
This document introduces Covenant Ko and provides some biographical information. It lists Ko's name, company, Github organization and profile, tech blog, and some chapter references. It also includes some sample code snippets and discount policy classes with calculating discount amounts. Various prices are mentioned ranging from 55p to 157p.
This document discusses Spring framework concepts including autowiring, dependency injection, and bean lifecycles. It includes questions about final variables, constructor injection vs setter injection, and troubleshooting autowiring issues. The autowired annotation and how it works internally using reflection is also covered.
The document discusses @Component, @Configuration, and @Bean annotations in Spring.
@Component scans packages to automatically detect classes to register as beans. @Configuration allows declaring and configuring beans directly within classes. @Bean defines methods that create and return beans.
The component scan process involves parsing the configuration, scanning classes based on include/exclude filters, registering bean definitions, and finishing bean initialization. Debugging shows how classes are parsed and beans registered.
Dependency injection types are compared, with constructor injection being most reliable and testable due to immutability and dependency detection. Circular dependencies can cause stack overflows at runtime.
1. The document discusses Spring bean scopes, including singleton, prototype, request, session, and global session scopes.
2. It notes that prototype scope creates a new bean instance each time it is requested, while singleton scope creates a single instance per Spring container.
3. The document cautions that prototype beans can cause stateful pollution if injected into stateless beans, and recommends that objects holding state typically should not be Spring beans.
IoC Bean CRUD describes the basic CRUD operations for beans within the Spring IoC container. It discusses how beans can be configured using XML or annotations, and how to read bean configuration using the AnnotationConfigApplicationContext or GenericXmlApplicationContext. It also mentions that while CRUD typically includes update operations, updates may not be necessary in Spring due to beans being immutable and the ability to refresh bean configuration at runtime using techniques like @RefreshScope.
- Beans in Spring are objects that are managed by the Spring IoC container. They form the backbone of a Spring application.
- Beans and their dependencies are configured in metadata that is used by the container to manage the complete lifecycle of a bean - instantiating, assembling, and configuring beans.
- There are two main ways to configure beans - using XML configuration or using annotations in Java code. Common annotations used include @Component, @Controller, @Service and @Repository.
This document discusses the SOLID principles of object-oriented design, beginning with an explanation of the Dependency Inversion Principle (DIP). DIP states that high-level modules should not depend on low-level modules, both should depend on abstractions. The document then explains the Open-Closed Principle (OCP), which states that software entities should be open for extension but closed for modification. Examples are given to illustrate each principle. The document aims to provide an introduction to SOLID and its benefits for maintainable object-oriented software design.
JPA 스터디 Week2 - Object Relational MappingCovenant Ko
This document discusses Object-Relational Mapping (ORM) and JPA. It begins with an introduction to the author and their background and credentials. It then poses some questions about ORM and defines it as mapping between object-oriented programming languages and relational databases. It discusses some of the challenges with ORM including differences in granularity, inheritance, identity, associations, and data navigation between objects and relational databases. It also covers ORM patterns like Active Record and Data Mapper and compares JPA, Hibernate, and Spring Data JPA. Finally, it provides a case study example of applying ORM and architectural patterns to an online ordering system.
This document contains information about Covenant Ko, including his background and links to his Github and blog. It discusses ORM and JPA, with JPA standing for Java Persistence API. It includes a pop quiz question asking about the relationships between ORM, JPA, and JPA providers like Hibernate. The document also references a case study on using Hazelcast for Hibernate second-level caching to improve performance.
This document contains notes from Covenant Ko on software design patterns and principles. It discusses functional decomposition, abstract data types, and object-oriented programming. It covers topics like the differences between assembling and composing code, open-closed and quality assurance principles, and relationships between abstract data types and objects. Links are provided to external references and resources on these topics.
The document discusses Covenant Ko and chapter 5. It mentions Covenant Ko's name and company (11번가) and links to his Github and tech blog. It then covers the GRASP pattern for software design, including information expert, controller and other patterns. It discusses the need for responsibility-driven design and applying the GRASP patterns.
- Covenant Ko is a founder and maintainer of the Github organization 'brave-people' and has a technical blog that has received over 410,000 visits
- He explains Anderson's Formula for calculating expected value, which takes into account probability of success (P) and payoff for success (S)
- Some tips he provides include making the common case fast, using static fields for caches but not databases, and that StringBuffer is thread-safe while StringBuilder is not
This chapter discusses Covenant Ko, who works at 11번가 and is the founder and maintainer of the Github organization '용감한친구들'. It also contains Ko's Github profile and tech blog. The chapter then discusses some problems around separation of concerns, propagation of changes, and cycle references. It questions where logic for finding linked or registered accounts should be placed. It introduces the concept of abstract data types and developing object-oriented applications based on this concept. It also mentions model-view separation in application development.
The document discusses the life cycle of Spring beans. It begins with an overview of how beans are defined using XML, stereotype annotations, and configuration. It then covers the key stages in the bean life cycle: 1) Context loading where the configuration is merged and validated, 2) Dependency injection where dependencies are injected either through constructors, setters or fields, and 3) A pop quiz about the final bean definition and how it can be modified through a BeanFactoryPostProcessor.
This document introduces Covenant Ko and provides some biographical information. It lists Ko's name, company, Github organization and profile, tech blog, and some chapter references. It also includes some sample code snippets and discount policy classes with calculating discount amounts. Various prices are mentioned ranging from 55p to 157p.
This document discusses Spring framework concepts including autowiring, dependency injection, and bean lifecycles. It includes questions about final variables, constructor injection vs setter injection, and troubleshooting autowiring issues. The autowired annotation and how it works internally using reflection is also covered.
The document discusses @Component, @Configuration, and @Bean annotations in Spring.
@Component scans packages to automatically detect classes to register as beans. @Configuration allows declaring and configuring beans directly within classes. @Bean defines methods that create and return beans.
The component scan process involves parsing the configuration, scanning classes based on include/exclude filters, registering bean definitions, and finishing bean initialization. Debugging shows how classes are parsed and beans registered.
Dependency injection types are compared, with constructor injection being most reliable and testable due to immutability and dependency detection. Circular dependencies can cause stack overflows at runtime.
1. The document discusses Spring bean scopes, including singleton, prototype, request, session, and global session scopes.
2. It notes that prototype scope creates a new bean instance each time it is requested, while singleton scope creates a single instance per Spring container.
3. The document cautions that prototype beans can cause stateful pollution if injected into stateless beans, and recommends that objects holding state typically should not be Spring beans.
IoC Bean CRUD describes the basic CRUD operations for beans within the Spring IoC container. It discusses how beans can be configured using XML or annotations, and how to read bean configuration using the AnnotationConfigApplicationContext or GenericXmlApplicationContext. It also mentions that while CRUD typically includes update operations, updates may not be necessary in Spring due to beans being immutable and the ability to refresh bean configuration at runtime using techniques like @RefreshScope.
- Beans in Spring are objects that are managed by the Spring IoC container. They form the backbone of a Spring application.
- Beans and their dependencies are configured in metadata that is used by the container to manage the complete lifecycle of a bean - instantiating, assembling, and configuring beans.
- There are two main ways to configure beans - using XML configuration or using annotations in Java code. Common annotations used include @Component, @Controller, @Service and @Repository.
This document discusses the SOLID principles of object-oriented design, beginning with an explanation of the Dependency Inversion Principle (DIP). DIP states that high-level modules should not depend on low-level modules, both should depend on abstractions. The document then explains the Open-Closed Principle (OCP), which states that software entities should be open for extension but closed for modification. Examples are given to illustrate each principle. The document aims to provide an introduction to SOLID and its benefits for maintainable object-oriented software design.