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>
<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- hibernate对jpa的支持包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${project.hibernate.version}</version>
</dependency>
<!-- c3p0 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>${project.hibernate.version}</version>
</dependency>
<!-- log日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!-- Mysql and MariaDB -->
<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">
<!--配置持久化单元
name：持久化单元名称
transaction-type：事务类型
RESOURCE_LOCAL：本地事务管理 我们当前是为本地操作
JTA：分布式事务管理 -->
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--配置JPA规范 服务提供商-->
<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" />
<!-- 因为hibernate 提供了JPA的实现也可以配置Hibernate 中属性-->
<property name="hibernate.show_sql" value="true" /> <!-- 显示sql -->
<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 后进行的学习小结，希望能帮助到在学习的朋友们
扫一扫
2801
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
