JPA的个人小结

女爷i 2023-06-30 06:52 16阅读 0赞

# JPA的个人小结 #

## 原生Jpa的概念和操作 ##

### 什么是原生Jpa ###

JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。

JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

### Jpa 的入门 ###

#### 一,创建Maven 工程导入Pom.xml坐标 ####

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.example</groupId>
        <artifactId>Jpa-test</artifactId>
        <version>1.0-SNAPSHOT</version>
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.hibernate.version>5.0.7.Final</project.hibernate.version>
        </properties>
        <dependencies>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-entitymanager</artifactId>
                <version>${project.hibernate.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-c3p0</artifactId>
                <version>${project.hibernate.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.17</version>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.6</version>
            </dependency>
        </dependencies>
    
    </project>

#### 二，在META-INF 中创建名为"Persistence.xml"资源配置文件 ####

<?xml version="1.0" encoding="UTF-8"?>
    <persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0">
        
        <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
            
            <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
            <properties>
                
                <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
                
                <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/customer" />
                
                <property name="javax.persistence.jdbc.user" value="root" />
                
                <property name="javax.persistence.jdbc.password" value="1024" />
    			
                <property name="hibernate.show_sql" value="true" /> 
                <property name="hibernate.format_sql" value="true" />
                <property name="hibernate.hbm2ddl.auto" value="update" />
            </properties>
        </persistence-unit>
    </persistence>

log4j配置文件

# Global logging configuration
    log4j.rootLogger=DEBUG, stdout
    # MyBatis logging configuration...
    log4j.logger.org.mybatis.example.BlogMapper=TRACE
    # Console output...
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

#### 三,配置实体类属性 ####

在实体类中要配置实体类属性和表中对应的属性,这里我以我创建的客户表为例

**@Entity**

作用：指定当前类是实体类。

**@Table**

作用：指定实体类和表之间的对应关系。

属性：

name：指定数据库表的名称

**@Id**

作用：指定当前字段是主键。

**@GeneratedValue**

作用：指定主键的生成方式。。

属性：

**strategy ：指定主键生成策略。**

**@Column**

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

属性：

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

unique：是否唯一

nullable：是否可以为空

inserttable：是否可以插入

updateable：是否可以更新

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

secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境\[重点\] \*这个不清楚

package com.wym.Entity;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name = "customer_table")
    public class Customer { 
        @Id//声明当前私有主键
        @GeneratedValue(strategy = GenerationType.IDENTITY)//主键生成策略
        @Column(name = "id")
        private Integer id;
        @Column(name = "name")
        private String name;
        @Column(name = "sex")
        private String sex;
        @Column(name = "tell")
        private Integer tell;
        @Column(name = "addr")
        private String addr;
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public void setSex(String sex) { 
            this.sex = sex;
        }
    
        public Integer getTell() { 
            return tell;
        }
    
        public void setTell(Integer tell) { 
            this.tell = tell;
        }
    
        public String getAddr() { 
            return addr;
        }
    
        public void setAddr(String addr) { 
            this.addr = addr;
        }
    
        @Override
        public String toString() { 
            return "Customer{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    ", tell=" + tell +
                    ", addr='" + addr + '\'' +
                    '}';
        }
    }

#### 四，配置Jpa 的管理器 ####

//获取配置文件得到Factory
            EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
            //创建实体类管理对象
            EntityManager em = factory.createEntityManager();
            //获取事务对象
            EntityTransaction transaction = em.getTransaction();
            //开启事务
            transaction.begin();
            Customer customer=new Customer();
            customer.setName("廖伟");
            customer.setAddr("井冈山");
            em.persist(customer);//添加数据
            //提交事务
            transaction.commit();
            //释放资源
            em.close();
            factory.close();

#### 五，优化Jpa 的创建过程 抽取一个工具类 ####

package com.wym.Entity.Utils;
    
    import javax.persistence.EntityManager;
    import javax.persistence.EntityManagerFactory;
    import javax.persistence.Persistence;
    
    /** * Jpa工具类 */
    public class JpaUtil { 
        // JPA的实体管理器工厂：相当于Hibernate的SessionFactory
        private static EntityManagerFactory factory=null;
        // 使用静态代码块赋值
        static{ 
          factory = Persistence.createEntityManagerFactory("myJpa");
        }
    
        /** * 提供一个方法管理对象 */
        public static EntityManager getFactory(){ 
            return  factory.createEntityManager();
        }
    
    }

### Jpa的CRUD 操作 ###

/** * EntityManager:提供了crud 的方法 * getTransaction : 获取事务对象 * persist ： 保存操作 * merge ： 更新操作 * remove ： 删除操作 * find/getReference ： 根据id查询 */

**上面我们创建了JpaUtils下面我们使用这个JpaUtils 工具类**

#### 一 ,保存操作persist ####

@Test
        public  void  testUtil(){ 
            EntityManager me = JpaUtil.getFactory();
            EntityTransaction transaction = me.getTransaction();
            transaction.begin();
            try { 
                Customer customer = new Customer();
                customer.setName("wengyanmin");
                customer.setSex("男");
                customer.setAddr("江西");
                customer.setTell(19312312);
    
                me.persist(customer);//保存
                transaction.commit();
            } catch (Exception e) { 
                e.printStackTrace();
                transaction.rollback();
            }
            me.close();
        }

#### 二，更新数据merge ####

@Test
        public void testMerge(){ 
            EntityManager me = JpaUtil.getFactory();
            EntityTransaction transaction = me.getTransaction();
            transaction.begin();
            try { 
                //查询前要先查询出对象
                Customer customer = me.find(Customer.class, 1l);
                customer.setAddr("深圳");
                //修改
                me.merge(customer);
                transaction.commit();
            } catch (Exception e) { 
                e.printStackTrace();
                transaction.rollback();
            }
            me.close();
        }

#### 三，删除数据remove ####

@Test
        public void testDelete(){ 
            EntityManager me = JpaUtil.getFactory();
            EntityTransaction transaction = me.getTransaction();
            transaction.begin();
            try { 
                //查询前要先查询出对象
                Customer customer = me.find(Customer.class, 1l);
                //删除
                me.remove(customer);
                transaction.commit();
            } catch (Exception e) { 
                e.printStackTrace();
                transaction.rollback();
            }
            me.close();
        }

#### 四，查询find 和 getReference ####

/** * 查询 根据id * find :直接获取对象本体 * getReference：延迟加载 */
    @Test
        public void testFind(){ 
            EntityManager me = JpaUtil.getFactory();
            EntityTransaction transaction = me.getTransaction();
            transaction.begin();
            try { 
                //查询前要先查询出对象
                //Customer customer = me.find(Customer.class, 1l);
                Customer c1 = me.find(Customer.class, 1L);
                Customer c2 = me.find(Customer.class, 1L);
                System.out.println(c1==c2);
                //返回true 有缓存
                //getReference：延迟加载
                Customer reference = me.getReference(Customer.class, 1l);
                //删除
                transaction.commit();
            } catch (Exception e) { 
                e.printStackTrace();
                transaction.rollback();
            }
            me.close();
        }

### Jpa的复杂查询 ###

jpa提供了一套复杂查询的 方式，就是使用JPQl,下面使用JPQL 来进行复杂的查询，JPQL 的语法是使用实体类中属性来进行语句的书写

#### 一， 查询所有 ####

@Test
        public  void test1(){ 
            EntityManager manager = JpaUtil.getFactory();
            EntityTransaction tx = manager.getTransaction();
    
            tx.begin();
            String jql="from Customer ";
            Query query = manager.createQuery(jql);
            List resultList = query.getResultList();
            for (Object cus:resultList
                 ) { 
                System.out.println(((Customer)cus));
            }
            tx.commit();
    
            manager.close();
        }

#### 二，分页查询 ####

@Test
        public  void testLimit(){ 
            EntityManager manager = JpaUtil.getFactory();
            EntityTransaction tx = manager.getTransaction();
    
            tx.begin();
            String jql="from Customer ";
            Query query = manager.createQuery(jql);
            //起始索引
            query.setFirstResult(1);
            //每页显示条数
            query.setMaxResults(2);
    
            List resultList = query.getResultList();
            for (Object cus:resultList
            ) { 
                System.out.println(((Customer)cus));
            }
            tx.commit();
            manager.close();
        }

#### 三，条件查询 ####

模糊查询:
     @Test
        public void testFindCondition(){ 
            EntityManager manager = JpaUtil.getFactory();
            EntityTransaction tx = manager.getTransaction();
    
            tx.begin();
            String jql="from Customer where name like ?";
            Query query = manager.createQuery(jql);
            //站位符
            query.setParameter(1, "weng%");
    
            //返回对象
            Object singleResult = query.getSingleResult();
            System.out.println(singleResult);
            tx.commit();
            manager.close();
        }
     /** * 下面的不写了： * * 排序查询： * jql: from Customer order by id desc * 统计查询： * jql * select count(id) from Customer */

**以上是我在学习jpa 后进行的学习小结，希望能帮助到在学习的朋友们**