SpringData --JPA small demo

Others 2021-03-31 14:15:56 views: null

1. The creation of database data table

CREATE DATABASE IF NOT EXISTS spring_data;
USE spring_data;
/*创建客户表*/
CREATE TABLE cst_customer (
    cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
    cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
    cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
    cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
    cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
    cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
    cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
    PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

2. Project creation

1. Import dependencies

<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>

2. Create an entity class for the customer table in the database

package com.cast.domain;

import java.io.Serializable;
import javax.persistence.*;

/**
 * 封装数据库中表的实体类
 */
@Entity    //该类是一个数据库表实体封装类
@Table(name = "cst_customer")    //指定数据库中对应表名
public class Customer implements Serializable {

    @Id    //主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)    //主键自增
    @Column(name = "cust_id")    //数据库表中的列名
    private Long custId;    //客户的主键

    @Column(name = "cust_name")
    private String custName;     //客户名称

    @Column(name="cust_source")
    private String custSource;     //客户来源
 
    @Column(name="cust_level")
    private String custLevel;     //客户级别

    @Column(name="cust_industry")
    private String custIndustry;     //客户所属行业

    @Column(name="cust_phone")
    private String custPhone;     //客户的联系方式

    @Column(name="cust_address")
    private String custAddress;     //客户地址

    // getter setter 方法....

    // toString() 方法....

}

ps: 

* @Id: 声明主键的配置
* @GeneratedValue: 配置主键的生成策略
* strategy
* GenerationType.IDENTITY ：自增，mysql
* * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
* GenerationType.SEQUENCE : 序列，oracle
* * 底层数据库必须支持序列
* GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
* GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
* @Column: 配置属性和字段的映射关系
* name：数据库表中字段的名称

3. Create a configuration file

A folder named META-INF must be created under resources, and a configuration file named persistence.xml must be created under this folder:

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

    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!-- 配置连接数据库的信息 -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/spring_data"/>
            <!-- 配置jpa实现方(hibernate)的配置信息 -->
            <property name="hibernate.show_sql" value="true" />
            <!-- value 的值为 create 表示删除原有的表再创建一张新表做操作 -->
            <!-- value 的值为 update 表示在原有的表上继续做操作 -->
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>

</persistence>

4. Create a tool class

package com.cast.utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 * 解决实体管理器工厂的浪费资源和耗时问题
 */
public class JpaUtil {

    private static EntityManagerFactory factory;

    static {
        //加载配置文件，创建entityManagerFactory  参数与配置文件中一致
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取EntityManager对象
     */
    public static EntityManager getEntityManager() {
       return factory.createEntityManager();
    }

}

3. Preparation of Jpa test method

* Jpa的操作步骤
* 1.加载配置文件创建工厂（实体管理器工厂）对象
* 2.通过实体管理器工厂获取实体管理器
* 3.获取事务对象，开启事务
* 4.完成增删改查操作
* 5.提交事务（回滚事务）
* 6.释放资源

1. Save

@Test
public void testSave() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager em = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //创建一个新对象并设置对象属性
    Customer customer = new Customer();
    customer.setCustName("张三");
    customer.setCustAddress("湖北省武汉市");
    customer.setCustIndustry("it行业");
    customer.setCustLevel("一级");
    customer.setCustPhone("1343434343");
    customer.setCustSource("网络");
    //4.执行保存操作
    em.persist(customer);
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    em.close();
}

2. Query by id

Load now

@Test
public void testFindOne() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = JpaUtil.getEntityManager();  
    //3.获取事务对象，开启事务
    EntityTransaction tx = entityManager.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.执行根据 id 查询操作 - 立即加载
    Customer customer = entityManager.find(Customer.class, 1L);
    System.out.print(customer);
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    entityManager.close();
}

Lazy loading (lazy loading)

@Test
public void testReference() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = entityManager.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.执行根据 id 查询操作 - 延迟加载（懒加载）
    Customer customer = entityManager.getReference(Customer.class, 1L);
    System.out.print(customer);
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    entityManager.close();
}

3. Modify according to id

@Test
public void testUpdate() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = entityManager.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.执行根据 id 修改操作
    //先查询
    Customer customer = entityManager.find(Customer.class, 1L);
    //再修改
    customer.setCustIndustry("it教育");
    //最后更新
    entityManager.merge(customer);
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    entityManager.close();
}

4. Delete according to id

@Test
public void testRemove() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager entityManager = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = entityManager.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.执行根据id删除操作
    //先查找
    Customer customer = entityManager.find(Customer.class, 1L);
    //再删除
    entityManager.remove(customer);
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    entityManager.close();
}

4. Preparation of Jpql statement test method

1. Search all

@Test
public void testFindAll() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager em = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.查询全部
    String jpql = "from Customer";
    //创建Query查询对象，query对象才是执行jqpl的对象
    Query query = em.createQuery(jpql);

    //发送查询，并封装结果集
    List list = query.getResultList();
    for (Object obj : list) {
        System.out.println(obj);
    }

    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    em.close();
}

2. Reverse order query

@Test
public void testOrders() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager em = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.倒序查询
    String jpql = "from Customer order by custId desc";
    Query query = em.createQuery(jpql);//创建Query查询对象，query对象才是执行jqpl的对象

    //发送查询，并封装结果集
    List list = query.getResultList();
    for (Object obj : list) {
        System.out.println(obj);
    }

    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    em.close();
}

3. Aggregate query

@Test
public void testCount() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager em = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.统计查询
    String jpql = "select count(custId) from Customer";
    Query query = em.createQuery(jpql);
    Object result = query.getSingleResult();
    System.out.println(result);
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    em.close();
}

4. Paging query

@Test
public void testPaged() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager em = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.分页查询
    String jpql = "from Customer";
    Query query = em.createQuery(jpql);
    //起始索引
    query.setFirstResult(0);
    //每页查询的条数
    query.setMaxResults(2);
    List list = query.getResultList();
    for(Object obj : list) {
        System.out.println(obj);
    }
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    em.close();
}

5. Conditional query

@Test
public void testCondition() {
    //1.加载配置文件创建工厂（实体管理器工厂）对象
    //2.通过实体管理器工厂获取实体管理器
    EntityManager em = JpaUtil.getEntityManager();
    //3.获取事务对象，开启事务
    EntityTransaction tx = em.getTransaction();  //获取事务对象
    tx.begin();  //开启事务
    //4.条件查询
    String jpql = "from Customer where custName like ? ";
    Query query = em.createQuery(jpql);
    query.setParameter(1, "张%");
    List list = query.getResultList();
    for(Object obj : list) {
        System.out.println(obj);
    }
    //5.提交事务（回滚事务）
    tx.commit();
    //6.释放资源
    em.close();
}

 

Source code download address:  https://pan.baidu.com/s/1RkvM1ZXNgyqYdFEUpytqng

 

Guess you like

Origin blog.csdn.net/weixin_42629433/article/details/84667415
Recommended
Ranking
error: (-215:Assertion failed) !_img.empty() in function ‘cv::imwrite‘
Database migration between Navicat servers
Minimum number of rotation of the array: Array
balenaEtcher for mac (make a boot disk software) v1.5.67
Custom processing serialization and deserialization in jackson
Mu-en-mask system development software
Mastering Regular Expressions
Find mileage Java--
Web pages can not directly concern the public micro-channel number how to do? A key to arouse public concern number of micro-channel solutions
[CodeForces - 739B] Alyona and a tree Tree + [difference] + bipartite
Daily
More
2024-05-12(28)
2024-05-11(32)
2024-05-10(34)
2024-05-09(32)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)
2024-05-03(8)

Code World

© 2018 codetd.com