springdatajpa之初识hibernate(一)

springdata jpa

springbootjpa 默认采用hibernate实现,只要springboot引入了jpa就把hibernate作为一个实现

hibernate 和 jpa 关系

hibernate

引入依赖

 <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.29</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

hibernate 是由jboss开发所以引入了jboss-logging,到时候集成spring会换掉
实体类

@Entity
@Builder
@Data
@Table(name = "users")
@AllArgsConstructor
@NoArgsConstructor
public class UserEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;
    private String password;
    @Column(name = "created_at")
    private Date createAt;
    @Column(name = "updated_at")
    private Date updateAt;

}

hibernate.cfg.xml(resource目录下)

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!--驱动程序-->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <!--访问的URL-->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/bms_test</property>
        <!--用户名-->
        <property name="hibernate.connection.username">root</property>
        <!--密码-->
        <property name="hibernate.connection.password">3306</property>
        <!--方言 表示的是告诉Hibernate框架当前 你要生成那个数据库下的SQL语句-->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
        <!-- hibernate根据映射关系自动建表
          默认: 不会创建表
          create: 没有表就创建，有表就删除重建。
          create-drop: 没有表就创建，有表就删除重建，使用完自动删表。
          update: 没有表就创建表，否则使用现有的表。
          validate: 不会创建表
       -->
        <property name="hibernate.hbm2ddl.auto">validate</property>

        <!-- 格式化输出生成的SQL语句
            show_sql  会在日志中记录sql 默认false ，生产环境不建议打印sql
            format_sql 是否格式化sql，默认fasle  不格式化他会一行打印
        -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <!-- 指定哪些实体需要进行orm映射-->
        <mapping class="com.pingfan.entity.UserEntity"></mapping>

    </session-factory>

</hibernate-configuration>

其中hibernate.dialect你可以根据org.hibernate.dialect包自主选择

public class HibernateTest {

    // 数据库会话
    private SessionFactory sf;

    @Before
    public void init(){
        //不给参数就默认加载hibernate.cfg.xml文件，
        sf=new Configuration()
                .configure().buildSessionFactory();
    }
    @Test
    public void testsave(){
        Session session = sf.openSession();
        session.beginTransaction();
        try {
            UserEntity user=UserEntity.builder().name("liuyuan~").email("123").password("456")
                    .build();
            session.save(user);
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }
        session.getTransaction().commit();
    }

    @Test
    public void testfind(){
        Session session = sf.openSession();
        session.beginTransaction();
        try {
            UserEntity userEntity = session.find(UserEntity.class, 97);
            System.out.println(userEntity);
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }
        session.getTransaction().commit();
    }
    @Test
    public void testload(){
        Session session = sf.openSession();
        session.beginTransaction();
        try {
            System.out.println("find");
            // 懒加载模式
            UserEntity userEntity = session.load(UserEntity.class, 97);
            System.out.println("user bean");
            System.out.println(userEntity);
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }
        session.getTransaction().commit();
    }

    @Test
    public void testsaveOrUpdate(){
        Session session = sf.openSession();
        session.beginTransaction();
        try {
            UserEntity user=UserEntity.builder()
                    .id(98)// 有id 更新 没有 添加
                    .name("liuyuan~").email("123").password("456")
                    .build();
            session.saveOrUpdate(user);
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }
        session.getTransaction().commit();
    }

    @Test
    public void testHQL(){ // HQL对其进行了扩展
        Session session = sf.openSession();
        session.beginTransaction();
        try {
            String hql="select * from users where id=:id";
            List<UserEntity> result = session.createNativeQuery(hql, UserEntity.class).setParameter("id", 97)
                    .getResultList();
            System.out.println(result.toString());
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }
        session.getTransaction().commit();
    }
}

spring项目使用jpa操作(resource目录下)
META-INF/persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--

JPA根据下面的配置信息创建EntityManagerFactory,一个项目中可以配置多个持久单元

name:为当前持久单元命名,可以通过该名称指定加载对应的配置信息
transaction-type 事务类型
    RESOURCE_LOCAL 本地事务管理
-->
    <persistence-unit name="hibernateJPA" transaction-type="RESOURCE_LOCAL">
        <!-- jpa 的实现方式        -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--指定扫描贴Entity实体类所在的jar包-->
        <class>com.pingfan.entity.UserEntity</class>
        <properties>

            <!--数据库的方言,告诉JPA当前应用使用的数据库-->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"/>
            <!--jpa的相关的配置信息-->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/bms_test"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="3306"/>

            <!--是否在控制台打印执行的sql语句-->
            <property name="hibernate.show_sql" value="true"/>
<!--            <property name="format_sql" value="true"/>-->

        </properties>
    </persistence-unit>
</persistence>

JpaTest

public class JpaTest {

    private EntityManagerFactory factory;

    @Before
    public void before(){
        //读取persistence.xml 配置文件 JPA 的配置需要定义在文件 META-INF/persistence.xml 中
        factory= Persistence
                .createEntityManagerFactory("hibernateJPA");
    }
    @Test
    public void add(){
        EntityManager em = factory.createEntityManager();
        EntityTransaction transaction = em.getTransaction();
        transaction.begin();

        try {
            UserEntity user = UserEntity.builder()
                    .name("limeili").password("456").email("limeili@aggrx.com")
                    .build();
            em.persist(user);
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        }
        transaction.commit();
    }
    @Test
    public void find(){
        EntityManager em = factory.createEntityManager();
        EntityTransaction transaction = em.getTransaction();
        transaction.begin();

        try {
            UserEntity userEntity = em.find(UserEntity.class, 98);
            System.out.println(userEntity);
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        }
        transaction.commit();
    }
    @Test
    public void getReference(){
        EntityManager em = factory.createEntityManager();
        EntityTransaction transaction = em.getTransaction();
        transaction.begin();

        try {
            UserEntity userEntity = em.getReference(UserEntity.class, 98);// 懒加载
            System.out.println("user ");
            System.out.println(userEntity);
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        }
        transaction.commit();
    }

    @Test
    public void useSql(){
        EntityManager em = factory.createEntityManager();
        EntityTransaction transaction = em.getTransaction();
        transaction.begin();

        try {
            String sql="select * from users where id=:id";
            Query query = em.createNativeQuery(sql,UserEntity.class)
                    .setParameter("id", 98);
            List resultList = query.getResultList();
            System.out.println(resultList);
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        }
        transaction.commit();
    }
}