JPA H2 redis 学习笔记

SpringBoot整合H2时：SpringBoot可以自动的配置内嵌的H2、HSQL、Derby数据库。你不需要提供任何链接URLs，只需要简单的提供一个你需要使用的内嵌数据库的依赖即可。
需要注意在不同情况下设置scope，这样就可以使用h2了，不需要做任何配置，这样就可以像使用mysql一样使用了，h2数据库是随着应用的启动而开始运行。
 
            com.h2database
            h2
            runtime
 

 #h2
spring.h2.console.enabled=true  //开启web console功能  http://localhost:8080/h2-console/

spring.datasource.platform=h2  //数据库平台是H2，可选
spring.h2.console.path=/h2   //设置访问路径 localhost:port/h2

#datasource
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.url=jdbc:h2:./data/db        是相对路径
spring.datasource.password=
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.H2Dialect  使用的语言

spring.datasource.schema=classpath:db/schema.sql，进行该配置后，每次启动程序，程序都会运行resources/db/schema.sql文件，对数据库的结构进行操作。//创建数据库表
spring.datasource.data=classpath:db/data.sql,进行该配置后，每次启动程序，程序都会运行resources/db/data.sql文件，对数据库的数据操作//向数据库插入数据
上面的是数据库执行的脚本文件，脚本文件要么不存在，如果存在就不能为空，否则会报错。

#spring.jpa.hibernate.ddl-auto=update这个配置不能设置，否则使用H2数据库必定报错。

spring.jpa.show-sql = true

spring.datasource.url=jdbc:h2:mem:test内存模式

#Windows当前用户路径
#spring.datasource.url = jdbc:h2:file:~/.h2/dbc2m;AUTO_SERVER=TRUE
#可执行程序的当前路径
spring.datasource.url = jdbc:h2:file:./dbh2/dbc2m;AUTO_SERVER=TRUE
#指定的静态配置路径
#spring.datasource.url = jdbc:h2:file:D:/db/.h2/dbc2m;AUTO_SERVER=TRUE

尤其是设置主键的增长方式时，值得注意，最好不用设置主键的增长方式为有程序决定。

JPA

对象与表的关系映射

hibernate实现

hibernate的配置文件

             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
   

   
       
        org.hibernate.jpa.HibernatePersistenceProvider
       
        com.demo.domain.Customer
       
       
           
           
           
           
           
           
           

           
           
           
           
           
           
            hibernate.hbm2ddl.auto 何种方式创造表  updata create none
            create如果有表，删除表再更新 
           
           
           
       
   

重点属性
hibernate.hbm2ddl.auto DDL语句的生成方式，值有create , update , none 。  create每次表的结构和数据发生变化，删除原表，建立新表。 update在原有表的基础上增加数据或者修改表的结构。

实体类与表关系的映射

实体类
       @Entity表明该类为实体类 @Table(name="table_name")实体类对应数据库中表的名字

实体类属性
      实体属性，主键属性  @Id 表明该属性是主键   @GeneratedValue(strategy=)增长方式 声明主键的增长方式的一种方法
      @GeneratedValue(generator = "uuid2") @GenericGenerator(name = "uuid2", strategy = "org.hibernate.id.UUIDGenerator")声明主键的增长方式的第二种方法
      
      @Column(name = "id",length = 36) 每个属性都必须要的注释，声明该属性与数据库表中与之对应的字段

主键生成策略
          GenerationType.IDENTITY: 自增 如 mysql数据库
     *          底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
     *      GenerationType.GenerationType.SEQUENCE: 序列 如 oracle数据库
     *          底层数据库必须支持序列
     *      GenerationType.GenerationType.TABLE: jpa提供的一种机制,通过一张数据库表的形式帮助我们完成主键自增
     *      GenerationType.GenerationType.AUTO: 由程序自动的帮助我们选择主键生成策略

hibernate操作的具体流程

1 创建实体类管理器工厂，加载配置文件
2 实体类管理器工厂，创建实体类管理器
3 实体类管理器获取事务对象，开启事务
4 实体类管理器，进行对数据的具体操作
5 提交事务，或者回滚事务
6 释放资源

具体代码

1   EntityManagerFactory entryManagerFactory = Persistence.createEntityManagerFactory("testdb-persistence-unit");

2    EntityManager manager = entryManagerFactory.createEntityManager();

3     Transaction  tx=manager.getTransaction()

        tx.begin()

4       CRUD   manager.persist()  manager.find()

5        tx.commit()
         tx.close()
6

EntityManager实体类管理器的方法

1，entityManager.persist(Object entity);　　新增数据；
   如果entity的主键不为空，而数据库没有该主键，会抛出异常；
   如果entity的主键不为空，而数据库有该主键，且entity的其他字段与数据库不同，persist后不会更新数据库；

 2、entityManager.find(Class entityClass, Object primaryKey);　　根据主键查找数据； 
   如果主键格式不正确，会抛出illegalArgumentException异常;
   如果主键在数据库未找到数据返回null；

 3、entityManager.remove(Object entity);　　删除数据；
   只能将Managed状态的Entity实例删除，由此Entity实例状态变为Removed；

 4、entityManager.merge(T entity);　　 将Detached状态的Entity实例转至Managed状态； 更新

 5、entityManager.clear();  将所有的Entity实例状态转至Detached状态；

 6、entityManager.flush();   将所有Managed状态的Entity实例同步到数据库；

 7、entityManager.refresh(Object entity); 加载Entity实例后，数据库该条数据被修改，refresh该实例，能得到数据库最新的修改，覆盖原来的Entity实例；

 find   reflush 方法作用类型，前者主动加载，后者懒加载，只有实体类用到才会立即加载。

 hibernate自身存在缓存，即一级缓存
 它对对象的操作会存储在自身的会话缓存中

 对象的三种状态
Managed：持久化受管对象，有id值，已经和Persistence Context建立了关联的对象。

Datached：游离态离线对象，有id值，但没有和Persistence Context建立关联的对象。

Removed：删除的对象，有id值，尚且和Persistence Context有关联，但是已经准备好从数据库中删除

状态名 作为java对象存在 在实体管理器中存在 在数据库存在

New yes no no

Managed yes yes yes

Detached no no no

Removed yes yes no

JPQL语句
面向对象的SQL语句，语法上与SQL相似，有位置参数和命名参数，位置参数用 ?1 ?2 表示，命名参数 :param1 :param2

entityManager实体类管理器执行JPQL语句

方法有
Query createNamedQuery(String name):创建查询的名称来创建一个命名查询，使用sql和jpql都可以
Query createNativeQuery（String SQLString）根据的原生的sql语句查询
Query createQuery（String jpqlString）根据指定的JPQL语句创建一个查询

它们都返回一个Query对象，这是因为要给参数赋值，Query的方法

Query setParmeter（String name， Object value）

Query对象方法的执行方法

List getResultList()执行JPQL的select语句，并且返回的是list集合

Object getSingleResult（）执行返回的那个结果的select语句

int executeupdate（）表示执行批量的删除和更新

Query setFirstResult（int startPosition）设置查询结果从第几条记录开始  这个方法和最好一个可以用来设置 分页查询的开始页码和页面数

Query setMaxResults(int maxResult)表示设置查询最多返回几条语句

例子

Query query =em.createQuery("select u from User u where u.userid =:param ");
//设置参数
query.setParameter("param",25);

Query query = em.createQuery("select u from User u where  u.userid=?1")
query.setParameter(1,25);

//命名参数查询时使用，参数类型为java.util.Date
Query setParameter(String name,java.util.Date value,TemporalType temporalType);
//命名参数查询时使用，参数类型java.util.Calendar
Query setParameter(String name,Calendar value,TemporalType temporalType);

还有位置参数的重载，除第一个参数的类型不同外，别无二致。

Spring data jpa

它的底层是hibernate实现，经过在一层的封装实现JPA思想。

相比hibernate它更加地简单，更加高效

引入相关的依赖

springboot

#dataSourse
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/library?charset=utf8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=root

#jpa
spring.jpa.show-sql=true
spring,jpa.hibernate.ddl_auto=  update create validate

spring.jpa.hibernate.naming.strategy=  命名策略，默认即可
　　1)、org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy   遇到大写字母 加”_”的命名。

　　2)、org.hibernate.cfg.ImprovedNamingStrategy   无修改命名 。

spring.jpa.properties.hibernate.dialect 

如果是spring sprin mvc
 //数据库配置

    
    
    
    
        
        
            
                
                
                
                
                
                
                
            
        
        
        
            
                com.bjsxt.pojo
            
        
    
    
    
    
        
    
    
    
    
    
    
    
    
    
    
    

springboot如果想用声明式事务，要开启@EnableTransactionManagement()

实体类的注解和hibernate关系实体类的注解别无二至。

操作实体类，只要继承两个接口，并给与泛型，救能直接使用它们的方法。

JpaRepository   封装了基本的CRUD
JpaSpecificationExcutor  复杂的操作

例如
@Repository
public interface myjunit implements JpaRepository,JpaSpecificationExcutor{

JPQL查询
@Query("SELECT p FROM Person p WHERE name LIKE %?1%")
Person findByName(String name);

Person findByName(String name);命名查询，根据name查询
    
}

JpaRepository class ID 实体类 实体类的主键类型
JpaSpecificationExcutor

JpaRepository 接口的方法
findAll
count, delete, deleteAll, deleteAll, deleteById, existsById, findById, save
count, exists, findAll, findOne

save 有id更新 无id保存

JpaSpecificationExcutor 接口
count(Specification spec)
Returns the number of instances that the given Specification will return.

List findAll(Specification spec) 列表查询
Returns all entities matching the given Specification.

Page findAll(Specification spec, Pageable pageable) 分页查询
Returns a Page of entities matching the given Specification.

List findAll(Specification spec, Sort sort) 排序查询
Returns all entities matching the given Specification and Sort.

Optional findOne(Specification spec) 

此外spring data jpa还支持JPQL查询

@Query

在继承了两个接口里，实现抽象方法，用@Query(value="")

@Query("SELECT p FROM Person p WHERE name LIKE %?1%")
Person findByName(String name);

@Query("SELECT p FROM Person p WHERE name LIKE %:name%")
Person findByName(@Param("name") String name);

@Modifying
@Query("UPDATE Person p SET p.name = :name WHERE p.id = :id")
void updatePersonName(@Param("id") Integer id, @Param("name") String name);

@Modifying注解来标识该方法执行的是更新或者删除操作

命名查询是 JPA 提供的一种将查询语句从方法体中独立出来，以供多个方法共用的功能。它根据特定的规则，让用户只写抽象方法，而不用去写JPQL语句，就能进行查询。

原理：
Person findByName(@Param("name") String name);

实体类定义JPQL SQL
@NamedQuery(name = "Person.findByName", query = "SELECT p FROM Person p WHERE p.name LIKE :name")
public class Person {
}

命名查询例子
public Customer findByCustName(String custName); 根据CustName进行查询

public List findByCustNameLike(String custName);根据CustName进行模糊查询

public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);多条件的模糊查询和精准查询

findBy --> from xxx(实体类)，属性名称 --> where custName =
是对jpql查询更深一层的封装
findBy查询，根据后面的属性查询

多表关系

一对一 

一对多
  一的一方 主表
  多的一点 从表
  外键 主表有一外键，为从表的主键

多对多
  
  中间表，多个外键，分别指向多表的主键

实体类的关系
继承 包含

包含关系描述表关系

一对多
集合set
@OneToMany(targetEntity=)
@JoinColumn(name=  referencedColumn=)外键

多对一
@ManyToOne
@JoinColumn

一对多 和 多对一 要合起来配置。

多对多配置
@ManyToMany()
@JoinTable()中间表

级联操作
cascade属性，要在@OneToMany等注解上。

springboot redis整合

           org.springframework.boot
           spring-boot-starter-data-redis

在和Redis整合中，相关的实体类需要序列化，才能存储在redis中，所以实体类继承序列化接口

spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=30000

redisTemplate模板，springboot对redis操作的模板，有两个泛型
redisTemplate
redisTemplate ，常用。

使用
redisTemplate.opsForValue().set("key")   opsForValue字符类型 opsForSet集合类型 opsForList()列表类型 opsForHash()哈希类型 opsForZSet

template.setValueSerializer()  设置key的序列化方式，通常设置键的序列化方式为字符串，易于观察。

相关的类
JedisConnectionFactory
RedisCacheManager

springboot redis集群配置
spring.redis.sentinel.master=mymaster 默认
spring.redis.sentinel.nodes=ip:port,ip:port
spring.redis.password=

第二种方式配置集群
spring:
  redis:
    cluster:
      nodes[0]: 127.0.0.1:6379
      nodes[1]: 127.0.0.1:6381

MYSQL redis 数据库整合
常用redis作为缓存，MYSQL作为写数据库