@Configuration
@Order(1)
public class ConfigerDB {
  //spring  jdbc
  @Bean("jdbcTemplate")
  public JdbcTemplate getJdbcTemplate() {
      var jdbcTemplate=  new JdbcTemplate();
      jdbcTemplate.setDataSource(getDataSource());
      return jdbcTemplate;
  }
  
  //配置数据源
  @Bean("hikariDataSource")
  public HikariDataSource getDataSource() {
   var dataSource = DataSourceBuilder.create();
    dataSource.url("jdbc:postgresql://localhost:5432/postgres");
    dataSource.driverClassName("org.postgresql.Driver");
    dataSource.username("postgres");
    dataSource.password("admin@123");
    //连接池，演示目的不设置参数了
    var pool= new HikariDataSource( );
    pool.setDataSource(dataSource.build());
    return  pool;
  }
}

@Aspect
@Component
public class MyAnnotationAOPAspect {
  @Around("execution(* com.hank.postgres.Service*.*(..))")
  public void around(ProceedingJoinPoint pjp) {
    try {
      pjp.proceed();
    } catch (Throwable e) {
      System.out.println(pjp.getTarget().getClass().getName() + "." + pjp.getSignature().getName() + ",执行错误，错误信息是" + e.getMessage());
       }
   }
}

@Configuration
@Order(2)
public class ConfigerTransantion {

  private HikariDataSource hikariDataSource;

  public ConfigerTransantion(HikariDataSource hikariDataSource){
    this.hikariDataSource=hikariDataSource;
  }

  @Bean("transactionTemplate")
  public TransactionTemplate getTransactionTemplate() {
    return new TransactionTemplate(getJdbcTransactionManager());
  }

  @Bean("jdbcTransactionManager")
  public JdbcTransactionManager getJdbcTransactionManager() {
    return new JdbcTransactionManager(hikariDataSource);
  }
}

@Component
public class Service {
  private final TransactionTemplate transactionTemplate;
  private final JdbcTemplate jdbcTemplate;

  //注入
  public Service(TransactionTemplate transactionTemplate,JdbcTemplate jdbcTemplate){
    this.transactionTemplate = transactionTemplate;
    this.jdbcTemplate=jdbcTemplate;
  }

  public void insert() throws Exception {
    final Exception[] exception = {new Exception()};
     var result = transactionTemplate.execute(p->{
         var i= jdbcTemplate.update("insert into \"order\" (id, name)values (?,?)",new Object[]{200,"name1"});
         var j = 0;
         //回滚点
         var savePoint= p.createSavepoint();
         try {
           j=jdbcTemplate.update("insert into \"order\" (id, name)values (?,?)",new Object[]{201,"name2"});
           var bar =1/0;
         }catch (Exception e){
           j=0;
           //回滚代码到 savePoint 对象定义执行的代码，
           p.rollbackToSavepoint(savePoint);
           //rollbackToSavepoint 意思是无论有无错误,都只执行回调点前的代码
           //不能 throw e ,这样回滚效果就会失效
           exception[0] =e;
         }finally {
           p.releaseSavepoint(savePoint);
         }
         return i+j;
      });
      System.out.println("更新成功次数:"+result);
      if(exception.length==1) throw exception[0];
  }
}

//测试
@ComponentScan({"com.hank"})
@EnableAspectJAutoProxy(exposeProxy = true)
public class Programmer {
  public static void main(String[] args) throws Exception {
    var context = new AnnotationConfigApplicationContext(Programmer.class);
    var bean =context.getBean(Service.class);
    bean.insert();
    context.close();
  }
}

// 声明式事务 需要有事务管理器，事务模板内部代码自己生成
@Configuration
@Order(2)
public class ConfigerTransantion {

  private HikariDataSource hikariDataSource;

  public ConfigerTransantion(HikariDataSource hikariDataSource){
    this.hikariDataSource=hikariDataSource;
  }
  
  @Bean("jdbcTransactionManager")
  public JdbcTransactionManager getJdbcTransactionManager() {
    return new JdbcTransactionManager(hikariDataSource);
  }
}

@Component
public class Service1 {
  private final JdbcTemplate jdbcTemplate;

  //注入
  public Service1(JdbcTemplate jdbcTemplate) {
    this.jdbcTemplate = jdbcTemplate;
  }
  
  //注解声明式事务
  @Transactional("jdbcTransactionManager")
  public void insert() {
    var i = jdbcTemplate.update("insert into \"order\" (id, name)values (?,?)", new Object[]{200, "name1"});
    var j = 0;
    var savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
    try {
      j = jdbcTemplate.update("insert into \"order\" (id, name)values (?,?)", new Object[]{201, "name2"});
      //var bar =1/0;
    } catch (Exception e) {
      j = 0;
      TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
      //编程式事务抛出错误，回滚会失效，注解不会,因为此时的事务访问是方法，而不是编程式事务的回调内的事务范围
      throw e;
    } finally {
      TransactionAspectSupport.currentTransactionStatus().releaseSavepoint(savePoint);
      System.out.println("更新成功次数:" + (i + j));
    }
  }
}

@ComponentScan({"com.hank"})
@EnableAspectJAutoProxy()
@EnableTransactionManagement
public class Programmer {
  public static void main(String[] args) throws Exception {
    var context = new AnnotationConfigApplicationContext(Programmer.class);
    var bean =context.getBean(Service1.class);
    bean.insert();
    context.close();
  }
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
  @AliasFor("transactionManager")
  String value() default "";
  //指定事务管理器名字，默认为transactionManager，当使用其他名字时需要明确指定
  @AliasFor("value")
  String transactionManager() default "";
   
  String[] label() default {};
  //指定事务传播行为，默认为Required，使用Propagation.REQUIRED指定
  Propagation propagation() default Propagation.REQUIRED;
  //指定事务隔离级别，默认为“DEFAULT”，使用Isolation.DEFAULT指定；
  Isolation isolation() default Isolation.DEFAULT;
  //指定事务超时时间，以秒为单位，默认-1表示事务超时将依赖于底层事务系统
  int timeout() default -1;

  String timeoutString() default "";
  //指定事务是否只读，默认false表示事务非只读
  boolean readOnly() default false;
  //指定一组异常类，遇到该类异常将回滚事务
  Class<? extends Throwable>[] rollbackFor() default {};
  //和 rollbackFor()功能一样
  String[] rollbackForClassName() default {};
  //指定一组异常类，即使遇到该类异常也将提交事务，即不回滚事务
  Class<? extends Throwable>[] noRollbackFor() default {};
  //和 noRollbackFor()功能一样 
  String[] noRollbackForClassName() default {};
}

@Transactional(transactionManager="jdbcTransactionManager",isolation = Isolation.READ_COMMITTED)

class Bar{
   @Transactional("jdbcTransactionManager")
   public void f1(){ f2()}
   @Transactional("jdbcTransactionManager")
   public void f2(){
   }
}

class OutService {
  @Autowired
  InnerService innerService;
  // 外层事务 do
  public void doo() {
    //事务1 do1
    innerService.do1(
      //TransactionSynchronizationManager.getCurrentTransactionName() 可以获取当前的事务名称
      System.out.println(TransactionSynchronizationManager.getCurrentTransactionName());
    );
    //事务2 do2
    innerService.do2();

    throw new Exception("");
  }
}

class Config {
  /**
   * 输出所有管理的实体
   * @param context
   * @return
   */
  public static Map.Entry<Object, EntityEntry>[] getManagedEntities(PersistenceContext context) {
    var map = context.reentrantSafeEntityEntries();
    return  map;
  }

  public void extracted(Consumer<Configuration> configurer, Consumer<Session> handler) {

    var cfg = new Configuration();

    //.configure()  在classpath根路径下搜索名为hibernate.cfg.xml的文件，如果没有找到将会抛出异常, 也可以指定 configure 方法参数为指定的路径
    //var cfg = new Configuration().configure();
    
    /*
    hibernate.cfg.xml
     <hibernate-configuration>
        <session-factory>
            <property name="xxx">yyy</property>
            //数据库和类映射 xml 文件
            <mapping resource="xxx.hbm.xml"/>
        </session-factory>
     </hibernate-configuration>
    */

    // dialect 指明具体联系的数据库类型，因为同一个数据库因为版本的不同，标准也会有差异, SQL 标准各个厂家完全遵守的
    cfg.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
    cfg.setProperty("hibernate.connection.driver_class", "com.mysql.cj.jdbc.Driver");
    cfg.setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/MyDB");
    cfg.setProperty("hibernate.connection.username", "root");
    cfg.setProperty("hibernate.connection.password", "root");
    cfg.setProperty("hibernate.show_sql", "true");
    cfg.setProperty("format_sql", "true");
    cfg.setProperty("use_sql_comments", "true");

    cfg.setProperty("hibernate.hbm2ddl.auto","update");

    //设置全局拦截器
    cfg.setInterceptor(new MyInterceptor());


    //外部继续配置
    configurer.accept(cfg);

    SessionFactory factory = null;
    Session session = null;

    //ServiceRegistry 是 Service 的注册表, 它为Service提供了一个统一的加载 / 初始化 / 存放 / 获取机制.
    var serviceRegistry=new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build();

    try {
      factory = cfg.buildSessionFactory(serviceRegistry);
      var ii=  factory.unwrap(SessionFactoryImplementor.class);
      ii.getServiceRegistry().getService(EventListenerRegistry.class).appendListeners(EventType.FLUSH,new MyEvent());


      session = factory.openSession();

      if (session.isConnected()) {
        System.out.println("连接已通");
        //关于 session 的测试
        handler.accept(session);
      }
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      if (session != null) {
        session.close();
      }
      if (factory != null) {
        factory.close();
      }
    }
  }


}

class MyInterceptor  extends  EmptyInterceptor {
  /**
   * 脏数据检查，可以知道那些字段发什么了什么变化
   * @param entity
   * @param id
   * @param currentState
   * @param previousState
   * @param propertyNames
   * @param types
   * @return
   */
  @Override
  public  boolean onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types) {
    for (int i = 0; i < propertyNames.length; i++) {
      var type = types[i];
      var newValue= currentState[i];
      var oldValue= previousState[i];
      System.out.println("Cargo 的属性："+propertyNames[i] +
          "， 属性类型:"+type.getName()+
          "， id:"+id+
          "， old value:"+oldValue+
          "， new value:"+newValue);
      //在持久化到数据库之前，还可以再次修改属性值
    }

    //返回 true ，在此方法里对 currentState 的修改会持久化到数据库.
    //返回 false, 不会把对 currentState 修改持久化到数据库
    return false;
  }
}

public class Programmer {
  public static void main(String[] args) throws ClassNotFoundException, SQLException {
    var config =new Config();
    config.extracted(cfg -> {
     /*
       可以代替 xml 方式的映射文件 <mapping resource="xxx.hbm..xml" />  持久化类
       如果有多个实体类，一个个添加是不是很麻烦
       只能是自己去封装了
      */
      cfg.addAnnotatedClass(Cargo.class);
      cfg.addAnnotatedClass(Person.class);
    }, 
    
    //业务逻辑
    session -> {
      session.beginTransaction();
      var cargo = session.get(Cargo.class,1);

      var context = session.unwrap(SessionImplementor.class).getPersistenceContext();
      //查询当前可管理实体
      System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
      Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
        System.out.println(p.getKey());
        System.out.println(p.getValue());
      });

      session.getTransaction().commit();
    });
  }

session.beginTransaction();

var cargo = session.get(Cargo.class,1);
var context = session.unwrap(SessionImplementor.class).getPersistenceContext();

//查询当前可管理实体
System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});

System.out.println("数据是否改变"+session.isDirty());
//false

cargo.setName("dirt");

System.out.println("数据是否改变"+session.isDirty());
//true

session.getTransaction().commit();

System.out.println("数据是否改变"+session.isDirty());
//false

/*
连接已通
Hibernate: select cargo0_.id as id1_0_0_, cargo0_.name as name2_0_0_ from Cargo cargo0_ where cargo0_.id=?
管理的实体个数：1
com.hank.entity.Cargo@3d1f558a
EntityEntry[com.hank.entity.Cargo#1](MANAGED)
数据是否改变false
Cargo 的属性：name， 属性类型:string， id:1， old value:bag， new value:dirt
数据是否改变true
Cargo 的属性：name， 属性类型:string， id:1， old value:bag， new value:dirt
Hibernate: update Cargo set name=? where id=?
数据是否改变false
*/

var context = session.unwrap(SessionImplementor.class).getPersistenceContext();
var entityManager =session.unwrap(EntityManager.class);
var sessionFactory=session.getEntityManagerFactory().unwrap(SessionFactory.class);

session.beginTransaction();
 var context=session.unwrap(SessionImplementor.class).getPersistenceContext();
 //查询当前可管理实体
 System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
 Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
   System.out.println(p.getKey());
   System.out.println(p.getValue());
 });

 var cargo = session.get(Cargo.class,1);
 cargo.setName("tool");
 System.out.println("session 是否有脏数据:"+session.isDirty());
 //属性缓存的作用，根据缓存的状态，提前生成SQL 语句，但是不会执行，执行要提交事务的时候
 //会生成 更新语句,同时会更新缓存的状态
 session.flush();

 System.out.println("session 是否有脏数据:"+session.isDirty());

 //会在缓存里找数据
 var cargo1 = session.get(Cargo.class,1);
 System.out.println(cargo.equals(cargo1));


 System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
 Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
   System.out.println(p.getKey());
   System.out.println(p.getValue());
 });


 session.getTransaction().commit();

session.beginTransaction();
var context=session.unwrap(SessionImplementor.class).getPersistenceContext();
//查询当前可管理实体
System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});

var cargo = session.get(Cargo.class,1);
cargo.setName("tools");
System.out.println("session 是否有脏数据:"+session.isDirty());

//清除 session 管理的所有实体
session.clear();

System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});

var cargo1 = session.get(Cargo.class,1);
System.out.println(cargo1.getName());
System.out.println("是否是缓存:"+cargo.equals(cargo1));

System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});
/*
管理的实体个数：0
Hibernate: select cargo0_.id as id1_0_0_, cargo0_.name as name2_0_0_ from Cargo cargo0_ where cargo0_.id=?
session 是否有脏数据:true
管理的实体个数：0
Hibernate: select cargo0_.id as id1_0_0_, cargo0_.name as name2_0_0_ from Cargo cargo0_ where cargo0_.id=?
tool
是否是缓存:false
管理的实体个数：1
com.hank.entity.Cargo@4f4c88f9
EntityEntry[com.hank.entity.Cargo#1](MANAGED)   
*/

var cargo=session.get(Cargo.class,1);
session.evict(cargo);
//jpa 方法 detach 同样的效果
//session.detach(cargo);
System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
  Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});
//1

session.beginTransaction();
var context=session.unwrap(SessionImplementor.class).getPersistenceContext();

//查询当前可管理实体
System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});


//立即加载
var cargo1=session.get(Cargo.class,1);
//懒加载,在使用属性的时候才会加载
var cargo2=session.load(Cargo.class,2);


//查询当前可管理实体
System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});

//使用属性的时候才加载
System.out.println(cargo2);

//查询当前可管理实体
System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
  System.out.println(p.getKey());
  System.out.println(p.getValue());
});

session.getTransaction().commit();
/*
  管理的实体个数：0
  Hibernate: select cargo0_.id as id1_0_0_, cargo0_.name as name2_0_0_ from Cargo cargo0_ where cargo0_.id=?
  管理的实体个数：1
  com.hank.entity.Cargo@4f327096
  EntityEntry[com.hank.entity.Cargo#1](MANAGED)
  Hibernate: select cargo0_.id as id1_0_0_, cargo0_.name as name2_0_0_ from Cargo cargo0_ where cargo0_.id=?
  com.hank.entity.Cargo@75e09567
  管理的实体个数：2
  com.hank.entity.Cargo@4f327096
  EntityEntry[com.hank.entity.Cargo#1](MANAGED)
  com.hank.entity.Cargo@75e09567
  EntityEntry[com.hank.entity.Cargo#2](MANAGED)
*/

 session.beginTransaction();
  var context=session.unwrap(SessionImplementor.class).getPersistenceContext();

  //查询当前可管理实体
  System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
  Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
    System.out.println(p.getKey());
    System.out.println(p.getValue());
  });


  //批量更新，如果批量数据比较大，缓存里不清空是比较危险的
  for (int i = 1; i < 9; i++) {
    var cargo=session.get(Cargo.class,i);
    cargo.setName(LocalDateTime.now().toString());
    //生成 sql 语句
    session.flush();
    // 删除缓存里的记录
    session.evict(cargo);
  }

  //查询当前可管理实体
  System.out.println("管理的实体个数："+context.getNumberOfManagedEntities());
  Arrays.stream(Config.getManagedEntities(context)).forEach(p->{
    System.out.println(p.getKey());
    System.out.println(p.getValue());
  });

  //一次性把所有 sql 语句发给数据库
  session.getTransaction().commit();
});

//返回的是游标
var scroll= session.createQuery("from Cargo ").scroll(ScrollMode.FORWARD_ONLY);
while (scroll.next()){
  //查询对象
  var cargo =(Cargo) scroll.get()[0];
  cargo.setName(LocalDateTime.now().toString());
  session.flush();
  session.clear();
}

@Entity
@Getter
@Setter
public class Person {
  @Id
  @Column(name = "id", nullable = false)
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;

  @Column(name = "name", nullable = true)
  String name;
}

@Component
public class ConfigerDB {

  /**
   * 配置数据源
   *
   * @return
   */
  @Bean("dataSource")
  public DataSource getDataSource() {
    var dataSource = DataSourceBuilder.create();
    dataSource.url("jdbc:mysql://localhost:3306/MyDB");
    dataSource.driverClassName("com.mysql.cj.jdbc.Driver");
    dataSource.username("root");
    dataSource.password("root");
    //连接池，演示目的不设置参数了
    var pool = new HikariDataSource();
    pool.setDataSource(dataSource.build());
    return pool;
  }

  /**
   * 配置 jpa 属性
   * @return
   */
  @Bean("jpaProperties")
  public JpaProperties getJpaProperties() {
    var jpaProperties = new JpaProperties() {
    };
    jpaProperties.setShowSql(true);
    //设置属性
    jpaProperties.setProperties(new HashMap<>() {
      {
        put("hibernate.hbm2ddl.auto", "update");
        put("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        put("hibernate.show_sql", "true");
      }
    });
    return jpaProperties;
  }

  /**
   * 提供 jpa 的实现者
   * spring  boot  默认就包含了 Hibernate 的包
   * Hibernate对Jpa的实现
   * @return
   */
  @Bean("jpaVendorAdapter")
  public JpaVendorAdapter getJpaVendorAdapter() {
    return new HibernateJpaVendorAdapter();
  }

  /**
   * 实体管理工厂
   * @param dataSource
   * @param jpaProperties
   * @param jpaVendorAdapter
   * @return
   */
  @Bean("myEntityManagerFactory")
  @Primary
  public LocalContainerEntityManagerFactoryBean getEntityManagerFactory(
      DataSource dataSource, JpaProperties jpaProperties, JpaVendorAdapter jpaVendorAdapter) {

    var localContainerEntityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();

    localContainerEntityManagerFactoryBean.setDataSource(dataSource);
    localContainerEntityManagerFactoryBean.setJpaVendorAdapter(jpaVendorAdapter);
    localContainerEntityManagerFactoryBean.setJpaPropertyMap(jpaProperties.getProperties());
    localContainerEntityManagerFactoryBean.setPersistenceUnitName("myPersistenceUnitName");

    //指定扫描的实体所在的包路径
    localContainerEntityManagerFactoryBean.setPackagesToScan("com.hank.entityModel");

    return localContainerEntityManagerFactoryBean;
  }
   
  /**
   * spring 需要的事务
   * @param myEntityManagerFactory
   * @return
   */
  @Bean("jdbcTransactionManager")
  public JpaTransactionManager getJdbcTransactionManager(LocalContainerEntityManagerFactoryBean myEntityManagerFactory) {
    return new JpaTransactionManager(myEntityManagerFactory.getObject());
  }
}

@ComponentScan({"com.hank"})
@EnableTransactionManagement
public class Programmer {
  public static void main(String[] args) throws Exception {
    var context = new AnnotationConfigApplicationContext(Programmer.class);
    {
      //这里不能通过字符串获取 bean ，因为这样获取到的是代理对象
      var localContainerEntityManagerFactoryBean = context.getBean(LocalContainerEntityManagerFactoryBean.class);

      
      //读取数据并在事务里修改数据
      {
        var entityManager =localContainerEntityManagerFactoryBean.getObject().createEntityManager();
        var transaction=entityManager.getTransaction();
        transaction.begin();

        System.out.println(entityManager);

        var person= entityManager.find(Person.class,1);
        System.out.println(person.getName());
        person.setName(LocalDateTime.now().toString());
        transaction.commit();
        entityManager.close();
      }

      //读取上面事务代码修改的数据
      {
        var entityManager =localContainerEntityManagerFactoryBean.getObject().createEntityManager();
        System.out.println(entityManager);

        var person= entityManager.find(Person.class,1);
        System.out.println(person.getName());
        entityManager.close();
      }
    }
  }
}
/*
SessionImpl(518349613<open>)
2022-12-07T11:14:06.420353
SessionImpl(5998675<open>)
2022-12-07T11:30:04.118294800
*/

@Component
class Dao {

  /**
   * 这里获取的是 EntityManager 代理
   * Shared EntityManager proxy for target factory 
   * [org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean@401c4250]
   * 如果有多个持久化单元，需要指定持久化单元的名字 --myEntityManagerFactory
   */
  @PersistenceContext(unitName = "myEntityManagerFactory")
  private EntityManager entityManager;

  /**
   * org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean@401c4250
   * 如果有多个持久化单元，需要指定持久化单元的名字 --myEntityManagerFactory
   */
  @PersistenceUnit(unitName = "myEntityManagerFactory")
  private EntityManagerFactory entityManagerFactory;

  @Transactional("jdbcTransactionManager")
  public void func1() {
    System.out.println(entityManager);
    //entityManager 是代理对象
    //entityManager 代理对象不能像 func2 那样使用事务，需要按照 spring 事务的使用方式使用
    var person = entityManager.find(Person.class, 1);
    person.setName(LocalDateTime.now().toString());
    System.out.println("设置数值:" + person.getName());
    entityManager.close();
  }
  
   /**
   * 验证 func1 事务
   * 在本方法里手动开启事务
   */
  public void func2() {
    System.out.println(entityManagerFactory);
    var entityManager = entityManagerFactory.createEntityManager();
    System.out.println(entityManager);
    //SessionImpl(1337346642<open>)
    //此处不是代理对象，不能使用 spring 的事务需要自己开启事务
    var transaction=entityManager.getTransaction();
    transaction.begin();

    var person = entityManager.find(Person.class, 1);
    System.out.println("读取数值:" + person.getName());

    person.setName(LocalDateTime.now().toString());
    System.out.println("设置数值:" + person.getName());

    transaction.commit();

    entityManager.close();
  }

  /**
   * 验证 func2 手动开启的事务
   */
  public void func3() {
    System.out.println(entityManagerFactory);
    var entityManager = entityManagerFactory.createEntityManager();
    System.out.println(entityManager);
    //SessionImpl(789367604<open>)

    var person = entityManager.find(Person.class, 1);
    System.out.println("读取数值:" + person.getName());

    entityManager.close();
  }
}

@ComponentScan({"com.hank"})
@EnableTransactionManagement
public class Programmer {
  public static void main(String[] args) throws Exception {
    var context = new AnnotationConfigApplicationContext(Programmer.class);

    context.getBean(Dao.class).func1();

    context.getBean(Dao.class).func2();

    context.getBean(Dao.class).func3();
  }

  /*
  Shared EntityManager proxy for target factory [org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean@401c4250]
  设置数值:2022-12-07T11:14:06.381306600
  org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean@401c4250
  SessionImpl(1337346642<open>)
  读取数值:2022-12-07T11:14:06.381306600
  设置数值:2022-12-07T11:14:06.420353
  org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean@401c4250
  SessionImpl(789367604<open>)
  读取数值:2022-12-07T11:14:06.420353
  */
}

//@Indexed 提升 @CompoentScan 扫描的效率
//spring jpa 定义的 Repository 是个空接口
@Indexed
public interface Repository<T, ID> {
}

public interface MyPersonRepository extends Repository<Person, Integer> {
    //方法定义查询，要以固定的前缀开头加属性表达式结尾
    public Person findDistinctByName(String name);
}

List<Person> findByAddressZipCode(string zipCode)
//或
List<Person> findByAddress_ZipCode(string zipCode)

@ComponentScan({"com.hank"})
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = {"com.hank.Pesis"},
    entityManagerFactoryRef = "myEntityManagerFactory",
    transactionManagerRef = "jdbcTransactionManager"
)
public class Programmer {
  public static void main(String[] args) throws Exception {

    var  context = new AnnotationConfigApplicationContext(Programmer.class);

    var repository = context.getBean(MyPersonRepository.class);

    // true
    System.out.println(Proxy.isProxyClass(repository.getClass()));
    //class com.sun.proxy.$Proxy62
    System.out.println(repository.getClass());
    //org.springframework.data.jpa.repository.support.SimpleJpaRepository@2fac80a8
    //代理对象代理的实现类是 SimpleJpaRepository
    System.out.println(repository);
    
    //方法 findByName 的实现在 SimpleJpaRepository 类里
    var person =repository.findDistinctByName("ok");
  }
}

public interface MyPersonRepository extends Repository<Person, Integer> {

  //查询部分字段，相比较声明查询的优点
  @Query(" select u.name from Person u where  u.id=1 and  u.name=?1")
  public String findByName1(String name);

  @Query("from Person u where  u.id=1 and  u.name=:name")
  public Person findByName2(@Param("name") String name);
  
  //原生查询
  @Query(value = "select  * from Person u where  u.id=1 and  u.name=:name", nativeQuery = true)
  public Person findByName3(@Param("name") String name);

  //还可以传入对象 :#{#person.name} 属于 SpEL 表达式
  @Query(value = "from Person u where  u.id=1 and  u.name=:#{#person.name}")
  public Person findByName4(@Param("person") Person person);
   
   //更新
  @Modifying
  @Transactional
  @Query(value = "update Person  u set u.name=?1 where u.id=?2 ")
  public int updatePerson(String name,int id);

  //删除
  @Modifying
  @Transactional
  @Query(value = "delete  from Person u where  u.id=?1")
  public int deletePerson(int id);

  //新增
  @Modifying
  @Transactional
  @Query(value = "insert into Person (name)  values(?1) ",nativeQuery = true)
  public int insetPerson(String name);
}

@ComponentScan({"com.hank"})
@EnableJpaRepositories(
    basePackages = {"com.hank.Pesis"},
    entityManagerFactoryRef = "myEntityManagerFactory",
    transactionManagerRef = "jdbcTransactionManager"
)
@EnableTransactionManagement
public class Programmer {
  public static void main(String[] args) throws Exception {

    var  context = new AnnotationConfigApplicationContext(Programmer.class);

    var repository = context.getBean(MyPersonRepository.class);

    // true
    System.out.println(Proxy.isProxyClass(repository.getClass()));
    //class com.sun.proxy.$Proxy62
    System.out.println(repository.getClass());
    //org.springframework.data.jpa.repository.support.SimpleJpaRepository@2fac80a8
    //代理对象代理的实现类是 SimpleJpaRepository
    System.out.println(repository);

    System.out.println(repository.findByName1("ok"));
    System.out.println(repository.findByName2("ok"));
    System.out.println(repository.findByName3("ok"));
    System.out.println(repository.findByName4(new Person(){{setName("ok");}}));

    System.out.println(repository.updatePerson("ok",1));
    System.out.println(repository.deletePerson(1));
    System.out.println(repository.insetPerson("bad"));
  }
  /*
  true
  class com.sun.proxy.$Proxy66
  org.springframework.data.jpa.repository.support.SimpleJpaRepository@5112b7
  ok
  com.hank.entityModel.Person@333d44f6
  com.hank.entityModel.Person@32b112a1
  com.hank.entityModel.Person@678586f0
  1
  1
  1
  */
}

 //还可以传入对象 :#{#person.name} 属于 SpEL 表达式
 //#{#entity} 表示的是 @Entity 指定的名字会 实体的类名
@Query(value = "from #{#entity} u where  u.id=1 and  u.name=:#{#person.name}")
public Person findByName4(@Param("person") Person person);

@Entity
@Getter
@Setter
//name = "Person.myNamedQuery"  用实体名称开头
@NamedQuery(name = "Person.myNamedQuery",query = "select c from Person c where c.id=?1")
public class Person {
  @Id
  @Column(name = "id", nullable = false)
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;

  @Column(name = "name", nullable = true)
  String name;
}

public interface QueryByExampleExecutor<T> {
	/**
	 * Returns a single entity matching the given {@link Example} or {@link Optional#empty()} if none was found.
	 *
	 * @param example must not be {@literal null}.
	 * @return a single entity matching the given {@link Example} or {@link Optional#empty()} if none was found.
	 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if the Example yields more than one result.
	 */
	<S extends T> Optional<S> findOne(Example<S> example);

	/**
	 * Returns all entities matching the given {@link Example}. In case no match could be found an empty {@link Iterable}
	 * is returned.
	 *
	 * @param example must not be {@literal null}.
	 * @return all entities matching the given {@link Example}.
	 */
	<S extends T> Iterable<S> findAll(Example<S> example);

	/**
	 * Returns all entities matching the given {@link Example} applying the given {@link Sort}. In case no match could be
	 * found an empty {@link Iterable} is returned.
	 *
	 * @param example must not be {@literal null}.
	 * @param sort the {@link Sort} specification to sort the results by, may be {@link Sort#unsorted()}, must not be
	 *          {@literal null}.
	 * @return all entities matching the given {@link Example}.
	 * @since 1.10
	 */
	<S extends T> Iterable<S> findAll(Example<S> example, Sort sort);

	/**
	 * Returns a {@link Page} of entities matching the given {@link Example}. In case no match could be found, an empty
	 * {@link Page} is returned.
	 *
	 * @param example must not be {@literal null}.
	 * @param pageable the pageable to request a paged result, can be {@link Pageable#unpaged()}, must not be
	 *          {@literal null}.
	 * @return a {@link Page} of entities matching the given {@link Example}.
	 */
	<S extends T> Page<S> findAll(Example<S> example, Pageable pageable);

	/**
	 * Returns the number of instances matching the given {@link Example}.
	 *
	 * @param example the {@link Example} to count instances for. Must not be {@literal null}.
	 * @return the number of instances matching the {@link Example}.
	 */
	<S extends T> long count(Example<S> example);

	/**
	 * Checks whether the data store contains elements that match the given {@link Example}.
	 *
	 * @param example the {@link Example} to use for the existence check. Must not be {@literal null}.
	 * @return {@literal true} if the data store contains elements that match the given {@link Example}.
	 */
	<S extends T> boolean exists(Example<S> example);

	/**
	 * Returns entities matching the given {@link Example} applying the {@link Function queryFunction} that defines the
	 * query and its result type.
	 *
	 * @param example must not be {@literal null}.
	 * @param queryFunction the query function defining projection, sorting, and the result type
	 * @return all entities matching the given {@link Example}.
	 * @since 2.6
	 */
	<S extends T, R> R findBy(Example<S> example, Function<FluentQuery.FetchableFluentQuery<S>, R> queryFunction);
}

public interface MyPersonRepository extends Repository<Person, Integer>, QueryByExampleExecutor<Person> {
     @Override
     List<Person> findAll(Example example);
}


@ComponentScan({"com.hank"})
@EnableJpaRepositories(
    basePackages = {"com.hank.Pesis"},
    entityManagerFactoryRef = "myEntityManagerFactory",
    transactionManagerRef = "jdbcTransactionManager"
)
@EnableTransactionManagement
public class Programmer {
  public static void main(String[] args) throws Exception {
    var context = new AnnotationConfigApplicationContext(Programmer.class);
    var repository = context.getBean(MyPersonRepository.class);
    
     //动态匹配的实体对象
     var person=new Person();
     person.setFirstName("ok3");
    
    // 因为 id 有默认值，需要排除
    var matcher= ExampleMatcher.matching().withIgnorePaths(Person_.ID);

    //字符串 Starting 匹配，也能对所有的字符串属性指定字符串匹配
    matcher= matcher.withMatcher(Person_.FIRST_NAME, ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.STARTING,true));
    // 方法2 matcher= matcher.withMatcher(Person_.FIRST_NAME, p->p.endsWith().ignoreCase());

    //用动态查询去匹配
    var list=repository.findAll(Example.of(person,matcher));
    list.forEach(p->{
      System.out.println(p);
    });
  }
}

@Entity
@Getter
@Setter
@ToString
public class Person {
  @Id
  @Column(name = "id", nullable = false)
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private int id;

  @Column(name = "firstName", nullable = true)
  String firstName;

  @Column(name = "lastName", nullable = true)
  String lastName;

  @Column(name = "personAge", nullable = true)
  int age;
}


@ComponentScan({"com.hank"})
@EnableJpaRepositories(
    basePackages = {"com.hank.Pesis"},
    entityManagerFactoryRef = "myEntityManagerFactory",
    transactionManagerRef = "jdbcTransactionManager"
)
@EnableTransactionManagement

public class Programmer {
  public static void main(String[] args) throws Exception {
    var context = new AnnotationConfigApplicationContext(Programmer.class);
    var repository = context.getBean(MyPersonRepository.class);


    var person=new Person();
    person.setFirstName("k1");
    person.setLastName("dA1");
    
    //数字类型的字段忽略掉，最好是用包装类型就不用在这里忽略了，因为 null 类型, Example B不会进行匹配
    var exampleMatcher= ExampleMatcher.matching().
        withIgnorePaths(Person_.ID).withIgnorePaths(Person_.AGE);

    var sort= Sort.by(Person_.FIRST_NAME).ascending();

    //可以在第二个参数里选取第一个数据
    var result=  repository.findBy(Example.of(person,exampleMatcher),p->p.sortBy(sort).first());

    System.out.println(result.isPresent()?result.get():null);
  }
}