. 标准化

   JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。

. 容器级特性的支持

   JPA框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。

. 简单方便

   JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用  javax.persistence.Entity进行注释，JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成

. 查询能力

   JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

. 高级特性

   JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。

-- 删除库

-- drop database demo_jpa;

-- 创建库

create database if not exists demo_jpa charset gbk collate gbk_chinese_ci;

-- 使用库

use demo_jpa;

-- 创建表

create table if not exists student(

    sid int primary key auto_increment,     -- 主键id

    sname varchar(10) not null,             -- 姓名

    sage tinyint unsigned default 22,        -- 年龄

    smoney decimal(6,1),                    -- 零花钱

    saddress varchar(20)                    -- 住址

)charset gbk collate gbk_chinese_ci;

insert into student values(1,"蚂蚁小哥",23,8888.8,"安徽大别山");

 <!--单元测试坐标-->

 <dependency>

     <groupId>junit</groupId>

     <artifactId>junit</artifactId>

     <version>4.12</version>

     <scope>test</scope>

 </dependency>

 <!--hibernate EntityManager是围绕提供JPA编程接口的Hibernate Core的一个包装

 支持JPA实体实例的生命周期，并允许你用标准的Java Persistence查询语言编写查询-->

 <dependency>

    <groupId>org.hibernate</groupId>

    <artifactId>hibernate-entitymanager</artifactId>

    <version>5.4.10.Final</version>

</dependency>

<!--hibernate集成C3P0连接池坐标-->

<dependency>

    <groupId>org.hibernate</groupId>

    <artifactId>hibernate-c3p0</artifactId>

    <version>5.4.10.Final</version>

</dependency>

<!--mysql驱动-->

<dependency>

    <groupId>mysql</groupId>

    <artifactId>mysql-connector-java</artifactId>

    <version>5.1.32</version>

</dependency>

<?xml version="1.0" encoding="UTF-8"?>

<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">

    <!--写在前面：这个配置文件必须放在资源目录（resources）下的META-INF里面，且配置文件名必须为persistence.xml-->

    <!--提示：这里的约束在IDEA里面已经存在了

            右击找到New ==> File and Code Templates ==>JPA==> Deployment descriptors==>persistence_2_0.xml-->

    <!--第一步：配置persistence-unit标签

            name：持久化单元名称，自己定义，后期通过name来查找当前的文件配置

            transaction-type：事务管理方实

                JPA：分布式事务管理（只有JPA集群的时候要写，要不然事务无效（数据库在多台服务器上））

                RESOURCE_LOCAL：本地事务（数据库就在一台服务上）

    -->

    <persistence-unit name="MyJPA_01" transaction-type="RESOURCE_LOCAL">

        <!--第二步：这里告诉了JPA，它的实现厂家是哪个 provider标签就是供应商的意思-->

        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--第三步：配置JPA的基本信息-->

        <properties>

            <!--配置连接数据库的四大属性  必须以javax.persistence.jdbc前缀 -->

            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>

            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/demo_jpa"/>

            <property name="javax.persistence.jdbc.user" value="root"/>

            <property name="javax.persistence.jdbc.password" value="123"/>

            <!--JPA实现方的配置信息

                hibernate.show_sql：是否在控制台上显示操作的SQL语句   true AND false

                hibernate.format_sql：是否对打印在控制台上的SQL语句进行格式化（前提要显示SQL） true AND false

                hibernate.hbm2ddl.auto：数据库表创建方式

                    create：配置文件被加载时，会把原来对应的表删除后再创建（表信息也将删除），没有表则创建新的表

                    update：配置文件被加载时，有对应的表则不创建，没有表则创建一个新的表

                    none：和没写一样，有表就正常操作，找不到对应的表就报错

                这里重要阐述一下：设置create在有(严格)外键约束的情况下，是无法删除表在创建的，所有这个时候的性能和update一样

           -->

            <property name="hibernate.show_sql" value="true"/>

            <property name="hibernate.format_sql" value="true"/>

            <property name="hibernate.hbm2ddl.auto" value="create"/>

        </properties>

    </persistence-unit>

</persistence>

/**

 * @Entity： 声明实体类

 * @Table： 配置实体类与表的关系

 *          name：当前对应的数据库表的名称

 */

@Entity

@Table(name = "student")

public class Student {

    /**

     * @Id： 声明当前字段为主键

     * @GeneratedValue 配置主键生成策略

     *      GenerationType.SEQUENCE：自增，mysql可以用

     *      GenerationType.IDENTITY：序列，oracle可以用

     *      GenerationType.TABLE：jpa提供的一种机制，通过一张表的方式来帮我们完成主键自增

     *      GenerationType.AUTO：由程序自动帮我们完成

     * @Column： 指定实体类属性和数据库表之间的对应关系

     *      name：指定数据库表的列名称。

     *      unique：是否唯一

     *      nullable：是否可以为空

     *      inserttable：是否可以插入

     *      updateable：是否可以更新

     *      columnDefinition: 定义建表时创建此列的DDL

     *      secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），

     *          该属性定义该列所在从表的名字搭建开发环境[重点]

     */

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    @Column(name = "sid")

    private int id;                 // 主键 自增长

    @Column(name = "sname")

    private String name;            //姓名

    @Column(name = "sage")

    private int age;                //年龄

    @Column(name = "smoney")

    private double money;           //零花钱

    @Column(name = "saddress")

    private String address;         //住址

    //后面省略构造方法/get/set/toString

}

public class Client {

    public static void main(String[] args) {}

    @Test   //这个使用单元测试 而且pom.xml坐标的范围仅供测试

    public void createStudent(){

        //此静态方法执行后会找到“MyJPA_01”的名字配置，然后根据配置文件来创建工厂（实体管理器）对象

        EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJPA_01");

        //通过实体管理器工厂来生产（创建）一个实体管理器

        EntityManager entityManager = factory.createEntityManager();

        //通过实体管理器获取一个事务对象

        EntityTransaction transaction = entityManager.getTransaction();

        //开启事务

        transaction.begin();

        //创建一个实体对象，后面保存

        Student student=new Student(0,"谢霆锋",30,8888.6,"北京顺义");

        //保存方法

        entityManager.persist(student);

        //提交事务

        transaction.commit();

        //先关闭实体管理器后关闭工厂

        entityManager.close();

        factory.close();

    }

}

 //@SequenceGenerator注解源码中的定义

@Repeatable(SequenceGenerators.class)

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

public @interface SequenceGenerator {

    //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的"generator"值中

    String name();

    //属性表示生成策略用到的数据库序列名称 我当前的Oracle数据库指定表的序列是"sid_seq"。

    String sequenceName() default "";

    //数据库catalog的名称

    String catalog() default "";

    //数据库schema的名称

    String schema() default "";

    //表示主键初识值，默认为0

    int initialValue() default 1;

     //表示每次主键值增加的大小，例如设置1，则表示每次插入新记录后自动加1，默认为50

    int allocationSize() default 50;

}

//@TableGenerator注解源码介绍

@Repeatable(TableGenerators.class)

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})

@Retention(RetentionPolicy.RUNTIME)

public @interface TableGenerator {

    //表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的"generator"值中

    String name();

    //表示表生成策略所持久化的表名，例如，这里表使用的是数据库中的"tb_generator"表名。

    String table() default "";

    //catalog和schema具体指定表所在的目录名或是数据库名

    String catalog() default "";

    String schema() default "";

    //属性的值表示在持久化表中，该主键生成策略所对应键值的名称。例如在"tb_generator"中将"gen_key"作为主键的键值

    String pkColumnName() default "";

    //属性的值表示在持久化表中，该生成策略所对应的主键。例如在"tb_generator"表中，将"gen_key"的值为"student_pk"。

    String pkColumnValue() default "";

    //属性的值表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。

    //例如，在"tb_generator"中将"gen_value"作为主键的值

    String valueColumnName() default "";

    //表示主键初识值，默认为0。

    int initialValue() default 0;

    //表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。

    int allocationSize() default 50;

    UniqueConstraint[] uniqueConstraints() default {};

    Index[] indexes() default {};

}

    @Test   //这个使用单元测试 而且pom.xml坐标的范围仅供测试

    public void createStudent(){

        //通过调用工具类来返回一个实体管理器

        EntityManager entityManager = JPAUtils.getEntityManager();

        //通过实体管理器获取一个事务对象

        EntityTransaction transaction = entityManager.getTransaction();

        //开启事务

        transaction.begin();

        //创建一个实体对象，后面保存

        Student student=new Student(0,"迪丽热巴",30,8888.8,"北京顺义");

        //保存方法

        entityManager.persist(student);

        //提交事务

        transaction.commit();

        //关闭实体管理器   工厂属于公用的所有不能关闭

        entityManager.close();

    }

    @Test   //这个使用单元测试 而且pom.xml坐标的范围仅供测试

    public void mergeStudent(){

        //通过调用工具类来返回一个实体管理器

        EntityManager entityManager = JPAUtils.getEntityManager();

        //通过实体管理器获取一个事务对象

        EntityTransaction transaction = entityManager.getTransaction();

        //开启事务

        transaction.begin();

        /*

            更新数据:

                <T> T find(Class<T> var1, Object var2);后面说到查询会详细说

            为什么会先查询后更新呢？因为方便，我现在如果要更新id为1的学生的姓名，

            那么如果我自己创建一个student对象，但是其它信息不确定，所有我就把数据全部

            查询出来通过set方法设置后再传入更新

         */

        Student student = entityManager.find(Student.class, 1);

        System.out.println("更新前的学生："+student);

        student.setName("王二麻");

        student.setAddress("伊拉克");

        Student merge = entityManager.merge(student);

        System.out.println("更新后的学生："+merge);

        //提交事务

        transaction.commit();

        //关闭实体管理器   工厂属于公用的所有不能关闭

        entityManager.close();

        //更新前的学生：Student{id=1, name='蚂蚁小哥', age=23, money=8888.8, address='安徽大别山'}

        //更新后的学生：Student{id=1, name='王二麻', age=23, money=8888.8, address='伊拉克'}

    }

    @Test   //这个使用单元测试 而且pom.xml坐标的范围仅供测试

    public void removeStudent(){

        //通过调用工具类来返回一个实体管理器

        EntityManager entityManager = JPAUtils.getEntityManager();

        //通过实体管理器获取一个事务对象

        EntityTransaction transaction = entityManager.getTransaction();

        //开启事务

        transaction.begin();

        //删除操作  先把指定id查询出来一个对象，然后把对象丢到删除方法上

        Student student = entityManager.find(Student.class, 1);

        entityManager.remove(student);

        //提交事务

        transaction.commit();

        //关闭实体管理器   工厂属于公用的所有不能关闭

        entityManager.close();

    }

    @Test   //这个使用单元测试 而且pom.xml坐标的范围仅供测试

    public void findStudent(){

        //通过调用工具类来返回一个实体管理器

        EntityManager entityManager = JPAUtils.getEntityManager();

        //立即加载

        Student studentA = entityManager.find(Student.class, 2);

        //延迟加载

        Student studentB = entityManager.getReference(Student.class, 2);

        /*

        区别：

            find是立即加载，一旦执行entityManager.find(...)就会去数据库查询，然后把对象封装到接收对象上

            getReference：是懒加载：一旦执行不会立即去数据库查询，而是等到后面某一行代码要使用到这个查询信息的时候

                            才去数据库做真正的查询

            懒加载的方式是基于代理方式完成懒加载的，一般我们都使用懒加载，因为有些查询的数据从头到尾都没使用到，

            那么懒加载就不会浪费查询性能，但是有些数据查询后立马或者某个地方确定要使用则可使用立即加载

         */

        //关闭实体管理器   工厂属于公用的所有不能关闭

        entityManager.close();

    }

方法：

    ①：createNativeQuery (String sqlString)                        Query

    ②：createNativeQuery (String sqlString, Class resultClass)     Query

    ③：createNativeQuery (String sqlString, String resultClass)    Query

参数介绍：

    String sqlString：这个是传入最基本的sql语句（原生SQL）

    Class  resultClass：传入指定映射的对象

    String resultClass：传入字符串的映射关系（前提得在类上注解指定）

返回值：

    Query：是一个和数据库打交道的对象，里面封装各种执行SQL语句及操作

    @Test

    public void createNativeQueryTest() {

        //通过调用工具类来返回一个实体管理器

        EntityManager entityManager = JPAUtils.getEntityManager();

        //获取事务并开启事务

        EntityTransaction transaction = entityManager.getTransaction();

        transaction.begin();

        //-------------------------------------------------------------

            //增加数据：

                String sql_insert = "insert into student (sname,sage,smoney,saddress) values(?1,?2,?3,?4)";

                //封装原生SQL代码 并设置占位符数据

                Query query_insert = entityManager.createNativeQuery(sql_insert);

                query_insert.setParameter(1,"王小二");

                query_insert.setParameter(2,25);

                query_insert.setParameter(3,1234.5);

                query_insert.setParameter(4,"江苏连云港");

                //调用添加操作

                int i_insert = query_insert.executeUpdate();

                System.out.println("成功数："+i_insert);

            //删除操作

                String sql_delete="delete from student where sid=?1";

                Query query_delete = entityManager.createNativeQuery(sql_delete);

                query_delete.setParameter(1,8);

                //调用删除操作

                int i_delete = query_delete.executeUpdate();

                System.out.println("删除成功数："+i_delete);

            //更新操作

                String sql_update="update student set sname=?1 where sid=?2";

                Query query_update = entityManager.createNativeQuery(sql_update);

                query_update.setParameter(1,"妲己");

                query_update.setParameter(2, 3);

                int i_update = query_update.executeUpdate();

                System.out.println("更新成功数："+i_update);

            //查询操作 多个

                Query query_select = entityManager.createNativeQuery("select * from student");

                //返回的数据默认就是List<Object[]>  直接写List也是返回List<Object[]>

                List<Object[]> list = query_select.getResultList();

                for(Object[] o:list){

                    System.out.println(Arrays.toString(o));

                }

            //查询操作 单个

                Query nativeQuery = entityManager.createNativeQuery("select * from student where sid=2");

                //默认返回的是Object类型 但是必须后面转为Object[] 才可以使用

                Object student = nativeQuery.getSingleResult();

                System.out.println(Arrays.toString((Object[])student));

        //-------------------------------------------------------------

        //提交事务

        transaction.commit();

        //关闭实体管理器   工厂属于公用的所有不能关闭

        entityManager.close();

    }

@Test

    public void createNativeQueryTest() {

        //通过调用工具类来返回一个实体管理器

        EntityManager entityManager = JPAUtils.getEntityManager();

        //查询全部

        Query query = entityManager.createNativeQuery("select * from student", Student.class);

        List<Student> students = query.getResultList();

        for(Student s:students){

            System.out.println(s);

        }

        //这个使用query调用getSingleResult() 返回单个对象

        //Object student = query.getSingleResult();

        //关闭实体管理器   工厂属于公用的所有不能关闭

        entityManager.close();

    }

第一组：

    功能：用来设置占位符指定的数据

        Query setParameter(int position, Object value);         这个是最常用的√

        <T> Query setParameter(Parameter<T> param, T value);

        Query setParameter(Parameter<Calendar> param, Calendar value, TemporalType temporalType);

        Query setParameter(Parameter<Date> param, Date value, TemporalType temporalType);

        Query setParameter(String name, Object value);

        Query setParameter(String name, Calendar value, TemporalType temporalType);

        Query setParameter(String name, Date value, TemporalType temporalType);

        Query setParameter(int position, Calendar value,TemporalType temporalType);

        Query setParameter(int position, Date value, TemporalType temporalType);

    例如：

        Query query = entityManager.createQuery("from Student where sid=?1");

        query.setParameter(1, 3);

/*------------------------------------------------------------------------------------------------------------*/

第二组：

    功能：用来进行分页操作，对查询的整张表指定从索引某处到某处

        Query setMaxResults(int maxResult);     //当前要查询几条记录数

        int getMaxResults();

        Query setFirstResult(int startPosition);    //当前的查询起始位

        int getFirstResult();

    介绍：上面set是设置值 get是返回值

    例如：

        Query query = entityManager.createQuery("from Student");

        query.setFirstResult(2);    //从表第二条记录数查询

        query.setMaxResults(2);     //查询2条记录数   limit 2,2

/*------------------------------------------------------------------------------------------------------------*/

第三组：

    功能：用来对查询的返回一条数据或多条数据

        List getResultList();       //返回查询的多条记录封装到集合

        Object getSingleResult();   //返回查询的单条记录赋值给Object

/*------------------------------------------------------------------------------------------------------------*/

第四组：

    功能：用来对数据的增删改

        int executeUpdate();

/*------------------------------------------------------------------------------------------------------------*/

第五组：

    功能返回第二组设置在上面的值

        Set<Parameter<?>> getParameters();

        Parameter<?> getParameter(String name);

        <T> Parameter<T> getParameter(String name, Class<T> type);

        Parameter<?> getParameter(int position);

        <T> Parameter<T> getParameter(int position, Class<T> type);

        <T> T getParameterValue(Parameter<T> param);

        Object getParameterValue(String name);

        Object getParameterValue(int position);