//jpa都是接口默认都是 SimpleJpaRepository 实现类，通过替换实现类并重写delete方法
@EnableJpaRepositories(repositoryBaseClass = CustomerBaseRepository.class)
public void JPAConfig{xxx}

public class CustomerBaseRepository<T extends AuditModel, ID> extends SimpleJpaRepository<T, ID> {
  
  public CustomerBaseRepository(constructor fill parent param);
  
  //override delete(T entity)
  @Override
  public void delete(T entity) {
  	entity.setDeleted(true);
    em.merge(entity);
  }
}

@Repository
public interface InvoiceRepository extends JpaRepository<Invoice, Long>, JpaSpecificationExecutor<Invoice> {
  
}

@NoRepositoryBean
public interface BaseRepository<T extends AuditModel, ID> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T>{

    @Modifying
    @Query("UPDATE #{#entityName} t SET t.deleted = true WHERE t.id = ?1")
    void logicDelete(ID id);

    @Modifying
    @Query("UPDATE #{#entityName} t SET t.deleted = true WHERE t.id = :#{#entity.id}")
    void logicDelete(@Param("entity") T t);

}

@Repository
public interface UserRepository extends BaseRepository<User, Long> {
}

@Test
public void testSave() {
    final User user = userRepository.findById(1L).get();
    user.setName("jay");
  	//don't do this!!!
    //userRepository.save(user);
}

/**
    t_user[user_address_id]  注意这个表多了一个field
    t_user_address[user_id]
*/
public class User {
    @OneToOne
    private UserAddress addr;
}
public class UserAddress {
  	@OneToOne
    @JoinColumn(name = "user_id")
  	private User user;
}

/**
    t_user[]
    t_user_address[user_id]
*/
public class User {
    @OneToOne(mapperBy="user")
    private UserAddress addr;
}

public class UserAddress {
  	@OneToOne
    @JoinColumn(name = "user_id")
  	private User user;
}

@OneToOne	FetchType fetch() default EAGER;
@OneToMany  FetchType fetch() default LAZY;
@ManyToOne	FetchType fetch() default EAGER;
@ManyToMany	FetchType fetch() default LAZY;

//way1: the default is -1, never batch fetch, every query get max 20
spring.jpa.properties.hibernate.default_batch_fetch_size = 20

//way2: @BatchSize  only use in @ManyToOne @OneToMany, @ManyToMany invalid
@Entity
public class User {
  	@BatchSize(size=20)
  	@OneToMany(mapperBy="user", fetch=FetchType.EAGER)
  	private List<Address> addresses;
}

//select * from user;
//select * from address where user_id in (1,2,3);


//way3:  @Fetch   only support ID or JointUniqueKey
@Entity
public class User {
  	@Fetch(value = FetchMode.JOIN)
  	@OneToMany(mapperBy="user", fetch=FetchType.EAGER)
  	private List<Address> addresses;
}

//way4: maintenance by useService, 
@Entity
public class User {
  	@Transient
  	private List<Address> addresses;
}
//select * from user u left join address on u.id = user_id;


//userServie
public User getUser {
	user.setAddresses(addressReporitory.findByUserId(1L));
  	return user;
}

@Data
@Builder
@AllArgsConstructor
@NoRepositoryBean
public class SearchCriteria {

    private String key;
    private Operator operation;
    private Object value;
    
    public enum Operator {
        EQ("="),
        NE("!="),
        GE(">="),
        LE("<=>"),
        LK(":");
        Operator(String operator){
            this.operator = operator;
        }
        private String operator;
    }
}

@AllArgsConstructor
public class CustomSpecification<Entity> implements Specification<Entity> {
    
    private SearchCriteria criteria;

    @Override
    public Predicate toPredicate(final Root<Entity> root, final CriteriaQuery<?> query, final CriteriaBuilder builder) {
        switch (criteria.getOperation()) {
            case EQ:
                return builder.equal(root.get(criteria.getKey()), criteria.getValue());
            case GE:
                return builder.greaterThanOrEqualTo(root.get(criteria.getKey()), criteria.getValue().toString());
            default:
                return null;
        }
    }
}

final CustomSpecification<Offering> nameCriteria = new CustomSpecification<>(new SearchCriteria("code", SearchCriteria.Operator.EQ, "test"));
final CustomSpecification<Offering> descriptionCriteria = new CustomSpecification<>(new SearchCriteria("description", SearchCriteria.Operator.EQ, "tester222"));
offeringRepository.findAll(Specification.where(nameCriteria).and(descriptionCriteria));

@MappedSuperclass
@Getter
@Setter
public abstract class BaseEntity implements Serializable {
	@Version
  	private Long version;
} 

//wait time = delay * (1.0D + random.nextFloat() * (multiplier - 1.0D))

//只有乐观锁异常才会重试，并且随机 + 1.5倍，避免引起重试风暴
@Retryable(value = ObjectOptimisticLockingFailureException.class, 
           backoff = @Backoff(multiplier = 1.5, random = true))

@Service
@Transactional
public class InvoiceServiceImpl implements InvoiceService {
  
  //may be don't careful call a wirte
  //or get a entity and set a new value for field
  @Override
  public void readMethod(){}
  
  @Override
  public void readMethod(){}
  
  @Override
  public void writeMethod(){}
  
}

@Service
@Transactional(readOnly = true)
public class InvoiceServiceImpl implements InvoiceService {
  
  @Override
  public void readMethod(){}
  
  @Override
  public void readMethod(){}
  
  @Transactional
  @Override
  public void writeMethod(){}
}

/**
 * 目前我们的解决办法,感觉都不是很优雅
 * 1.inject the applicationContext
 * 2.inject self class
 * 3.methodB move to another class
*/
public class SomeServiceImpl{
  @Transactional
  public void methodA(){
    //transaction failure
    this.methodB();
  }
  //新开一个事务
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void methodB();
}
```  
<div class="note success"><p> ** 最佳实践（不一定，提供多一种稍微舒服点的封装类）**   <br />
利用spring的机制和JDK8的 Function 机制实现事务，封装通用处理组件，真正执行的是在 Function 类中，肯定也会被动态代理包装；</p></div>

```java
//方法1:他是单例的，会有现成安全问题，尽量自己new并注入entityManager（不推荐）
private TransactionTemplete transactionTemplete;
//方法2
@Component
public class TransactionHelper {
  /**
  	利用spring的机制和JDK8的 Function 机制实现事务
  */
  @Transactional(rollbackFor = Exception.class)
  public <T, R> R transactional(Function<T, R> function, T t) {
    return function.apply(t);
  }
}

@Service
@RequiredArgsConstructor
public class SomeService {
 	private final TransactionHelper transactionHelper;
  
  	public UserInfo methodA(Long userId) {
      return transactionHelper.transactional((uid) -> this.methodB(uid), userId);
    }
}
```  

### Real SQL（Only MySQL）
我们在开发中调试的时候经常想看到真实执行的SQL，或者开启事务的状态；而JPA的日志往往都是格式化的，用 ? 来替代参数，SQL复杂的情况下自己组装太痛苦了，那么有没有办法看到 SQL 真实的执行语句呢？
```java
//select * from invoices where invoice.id = ?
//binding parameter [1] as [BIGINT] - [39777]

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope> //important
</dependency>

@DataJpaTest
public class TestJpa {

    @Autowired
    private UserRepository userRepository;

    @DisplayName("test save")
    @Test
    public void testSave() {
        final User user = new User();
        user.setName("asd");
        userRepository.save(user);
    }
}

@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
    
    xxx...
    
    @Transactional
    @Override
    public <S extends T> S save(S entity) {
    
        Assert.notNull(entity, "Entity must not be null.");
        
        if (entityInformation.isNew(entity)) {
			em.persist(entity);
			return entity;
        } else {
			return em.merge(entity);
        }
	}
}

public class MyJpaRepo implements CrudRepository {
    EntityManager entityManager;
    Class clazz;
    //核心的entityManager传进来，spring提供给我们
    //clazz则是动态的 entity 怎么肯定也不能写死了吧。范型也可以不过后续处理麻烦点讲解就用简单的方式
    public MyJpaRepo(final EntityManager entityManager, final Class clazz) {
        this.entityManager = entityManager;
        this.clazz = clazz;
    }

    @Override
    public Optional findById(final Object o) {
        System.out.println("---my customer repository---findById");
        return Optional.of(entityManager.find(clazz, o));
    }
    
    //other override ignore 
}

public class MyJdkDynamicProxy implements InvocationHandler {

    MyJpaRepo myJpaRepo;

    //构造进真实调用对象
    public MyJdkDynamicProxy(final MyJpaRepo myJpaRepo) {
        this.myJpaRepo = myJpaRepo;
    }

    @Override
    public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
        return myJpaRepo.getClass().getMethod(method.getName(), method.getParameterTypes()).invoke(myJpaRepo, args);
    }
}

public static void main(String[] args) throws ClassNotFoundException {
    final AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Config.class);

    final EntityManager nativeEntityManager = getEntityManager(annotationConfigApplicationContext);

    final Class<?> clazz = getT(UserRepository.class);

    final MyJpaRepo myJpaRepo = new MyJpaRepo(nativeEntityManager, clazz);

    //spring做的事情
    UserRepository userRepository = (UserRepository) Proxy.newProxyInstance(
            UserRepository.class.getClassLoader(),
            new Class[]{UserRepository.class},
            new MyJdkDynamicProxy(myJpaRepo));

    System.out.println(userRepository.findById(20L));
}

//打印结果：
//---my customer repository---findById
//Optional[User{id=20, name='asd'}]

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(MyJPABeanDefinitionRegistrar.class)
public @interface EnableMyJPA {

    String[] packages() default {};

}

public class MyJPABeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
        Map<String, Object> annotationAttributesMap = annotationMetadata.getAnnotationAttributes(EnableMyJPA.class.getName());
        AnnotationAttributes annotationAttributes = Optional.ofNullable(在·AnnotationAttributes.fromMap(annotationAttributesMap)).orElseGet(AnnotationAttributes::new);
        // 获取需要扫描的包
        String[] packages = retrievePackagesName(annotationMetadata, annotationAttributes);

        //custom class filters 构造我们自己的自定义扫描器，非常重要！！！
        //因为spring只会扫描实现类，接口是会忽略的，而我们的仓储就是一个接口！！
        final MyJPAPathBeanDefinitionScanner myScanner = new MyJPAPathBeanDefinitionScanner(registry);
        //通过自定义扫描器扫描出我们的仓储接口
        final Set<BeanDefinitionHolder> beanDefinitionHolders = myScanner.doScan(packages);
        
        //这一步最重要！！把我们的接口通过的动态代理注入Spring
        covertCandidateComponents(beanDefinitionHolders);
    }
    
    private String[] retrievePackagesName(AnnotationMetadata annotationMetadata, AnnotationAttributes annotationAttributes) {
      //代码略，读取我们注解中定义的包名
    }
    
    /**
     * 注册 BeanDefinition
     */
    private void covertCandidateComponents(Set<BeanDefinitionHolder> beanDefinitionHolders) {
        beanDefinitionHolders.forEach(b -> {
            final ScannedGenericBeanDefinition beanDefinition = (ScannedGenericBeanDefinition) b.getBeanDefinition();

            final String beanClassName = beanDefinition.getBeanClassName();

            //ConstructorResolver.class
            //convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
            //beanClassName后续Spring会推断出来对应的Class<?>
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName);

            //偷天换日   mybatis jpa
            //！！核心 factoryBean 为什么要用FactoryBean,
            beanDefinition.setBeanClass(JpaFactoryBean.class);
        });
    }
}

//核心
public class JpaFactoryBean implements FactoryBean { 
    @Autowired
    private LocalContainerEntityManagerFactoryBean factory;

    private Class<?> repoInterface;

    public JpaFactoryBean(final Class<?> repoInterface) {
        this.repoInterface = repoInterface;
    }
    
    @Override
    public Object getObject() throws Exception {

        final EntityManager nativeEntityManager = factory.createNativeEntityManager(null);

        //拿到当前接口的父接口
        final ParameterizedType parameterizedType = (ParameterizedType) repoInterface.getGenericInterfaces()[0];
        //拿到第一个枚举
        final Type type = parameterizedType.getActualTypeArguments()[0];
        final Class<?> clazz = Class.forName(type.getTypeName());

        final MyJpaRepo myJpaRepo = new MyJpaRepo(nativeEntityManager, clazz);

        //spring做的事情，真正的去调用我们的动态代理类。就可以跟前面手动的动态代理串起来了
        return Proxy.newProxyInstance(
                repoInterface.getClassLoader(),
                new Class[]{repoInterface},
                new MyJdkDynamicProxy(myJpaRepo));
    }

    @Override
    public Class<?> getObjectType() {
        return repoInterface;
    }
}

/**
 * 自定义扫描器
 * 原有的不变，通过这个类动态注册
 *
 * @author jay
 * @date 05 Dec 2021
 */
public class MyJPAPathBeanDefinitionScanner extends ClassPathBeanDefinitionScanner {
    public MyJPAPathBeanDefinitionScanner(final BeanDefinitionRegistry registry) {
        super(registry);
    }
    @Override
    protected boolean isCandidateComponent(final AnnotatedBeanDefinition beanDefinition) {
        //是一个接口就返回true
        return beanDefinition.getMetadata().isInterface();
    }
    @Override
    protected Set<BeanDefinitionHolder> doScan(final String... basePackages) {
        return super.doScan(basePackages);
    }
}

@Configuration
@EnableTransactionManagement
@EnableMyJPA(packages = "com.kok.jpasource.repo")
public class Config3 {
    public void dataSourceConf(){xxx}
}

public class MyJPATest {

    public static void main(String[] args) {
        final AnnotationConfigApplicationContext ioc = new AnnotationConfigApplicationContext(Config3.class);

        final TestRepository testRepository = ioc.getBean(TestRepository.class);

        System.out.println(testRepository.findById(20L));
    }
}

---my customer repository---findById  !!!说明调用了我们自己的仓储
Optional[User{id=20, name='asd'}]