JPA实现增删改查

于 2019-12-03 14:17:29 发布
阅读量422 收藏
点赞数
分类专栏： 方法实现 文章标签： JPA实现增删改查
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Lucky_BonnenuIt/article/details/103366287
版权

JPA实现增删改查

  • 导入jar包
//添加依赖
    <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>
  • 配置文件
<!--必须放在WETA_INF下，文件名为persistence.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--需要配置persistence-unit节点
        持久化单元：
            name：持久化单元名称
            transaction-type：事务管理的方式
                    JTA：分布式事务管理
                    RESOURCE_LOCAL：本地事务管理
                    mysql单表5万条
                    mycat
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!--可选配置：配置jpa实现方的配置信息-->
        <properties>
            <!-- 数据库信息
                用户名，javax.persistence.jdbc.user
                密码，  javax.persistence.jdbc.password
                驱动，  javax.persistence.jdbc.driver
                数据库地址   javax.persistence.jdbc.url
            -->
            <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:///jpa"/>

            <!--配置jpa实现方(hibernate)的配置信息
                显示sql           ：   false|true
                自动创建数据库表    ：   hibernate.hbm2ddl.auto
                        create       : 程序运行时创建数据库表（如果有表，先删除表再创建）
                        update       ：程序运行时创建表（如果有表，不会创建表）
                        none         ：不会创建表

            -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" />
        </properties>
    </persistence-unit>

</persistence>
  • 实体类
import javax.persistence.*;
import java.util.SimpleTimeZone;

@Entity
//@Table(name="t_user")
public class User {

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

    private String password;

    private Integer age;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}
  • 测试类
import com.srzx.entity.User;
import org.junit.Test;

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

public class TestUser {

      /*
           1.加载配置文件创建工厂（实体管理器工厂）对象
     *     2.通过实体管理器工厂获取实体管理器
     *     3.获取事务对象，开启事务
     *     4.完成增删改查操作
     *     5.提交事务（回滚事务）
     *     6.释放资源
     *     增，删，改要使用事物
     *     查询不需要。
   */
      @Test
      public void testAddUser(){
          //1.加载配置文件创建工厂（实体管理器工厂）对象
          EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
          //2.通过实体管理器工厂获取实体管理器
          EntityManager entityManager = entityManagerFactory.createEntityManager();
          //3.获取事务对象，开启事务
          EntityTransaction transaction = entityManager.getTransaction();
          transaction.begin();
          //4.完成增删改查操作
          for(int i = 1; i < 101; i++ ){

              User user = new User();
              //user.setId(1);
              user.setUserName("zhangsan"+i);
              user.setPassword("123456"+i);
              user.setAge(20);

              entityManager.persist(user);//保存用户

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

      }

    /**
     * 根据id查询客户
     *  使用find方法查询：
     *      1.查询的对象就是当前客户对象本身
     *      2.在调用find方法的时候，就会发送sql语句查询数据库
     *  立即加载
     */
    @Test
    public void testFind(){
        //1.加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //3.获取事务对象，开启事务
        // EntityTransaction transaction = entityManager.getTransaction();
        // transaction.begin();
        //4.完成增删改查操作
        User user = entityManager.find(User.class, 1);
        System.out.println(user);
        //5.提交事务（回滚事务）
        // transaction.commit();
        //6.释放资源
        entityManager .close();
        entityManagerFactory.close();
    }

    /*
   getReference延迟加载
   什么用什么时候查。
  */
    @Test
    public void testReference(){
        //1.加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //3.获取事务对象，开启事务
        // EntityTransaction transaction = entityManager.getTransaction();
        // transaction.begin();
        //4.完成增删改查操作
        User user = entityManager.getReference(User.class,1);
        System.out.println(user);
        //5.提交事务（回滚事务）
        // transaction.commit();
        //6.释放资源
        entityManager .close();
        entityManagerFactory.close();
    }

    @Test
    public void testUpdate(){
        //1.加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //4.完成增删改查操作
        //4.1 先通过ID查询出这个对象
        User user = entityManager.find(User.class, 1); //持久态  和数据库有联系  ID  获取持久态对象。
        // 4.2修改对象
        user.setAge(30);
        user.setPassword("111111");
        //4.3提交
        entityManager.merge(user); 
        //5.提交事务（回滚事务）
        transaction.commit();
        //6.释放资源
        entityManager .close();
        entityManagerFactory.close();
        System.out.println(user);//游离态 ID
    }

    /*
  瞬时态   新创建的对象,并且没有ID  添加操作
  持久态   和数据库有联系，并且有id 删除和修改必须保证对象是持久态对象。
  游离态   和数据库没有联系，有ID
     */
    @Test
    public void testDelete(){
        //1.加载配置文件创建工厂（实体管理器工厂）对象
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //2.通过实体管理器工厂获取实体管理器
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //3.获取事务对象，开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        //4.完成增删改查操作
        //4.1 先通过ID查询出这个对象
        User user = entityManager.find(User.class, 1);
        //4.2提交删除
        entityManager.remove(user);
        //5.提交事务（回滚事务）
        transaction.commit();
        //6.释放资源
        entityManager .close();
        entityManagerFactory.close();
    }

}

//查询方法
import com.srzx.entity.User;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import java.util.List;

public class TestUser2 {

    /*查询所有*/
    @Test
    public void testFindAll() {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        // EntityTransaction transaction = entityManager.getTransaction();
        //transaction.begin();
        //sql select * from user（表名）
        //jpql   from User(实体类名)
        String jqpl = "from User";
        //String jqpl = "from User order by id desc";
        Query query = entityManager.createQuery(jqpl);
        List<User> resultList = query.getResultList();
        for (User user : resultList) {
            System.out.println(user);
        }
        //transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    /*排序：倒序*/
    @Test
    public void testFindAllDesc() {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        // EntityTransaction transaction = entityManager.getTransaction();
        //transaction.begin();
        //sql select * from user（表名）
        //jpql   from User(实体类名)
        //String jqpl = "from User";
        String jqpl = "from User order by id desc";
        Query query = entityManager.createQuery(jqpl);
        List<User> resultList = query.getResultList();
        for (User user : resultList) {
            System.out.println(user);
        }
        //transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    /*分页*/
    @Test
    public void testFindAllLimt() {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        // EntityTransaction transaction = entityManager.getTransaction();
        //transaction.begin();
        //sql select * from user limit 0,5
        //jpql   from User(实体类名)
        //String jqpl = "from User limit 0,5";
        String jqpl = "from User order by id desc";
        Query query = entityManager.createQuery(jqpl);
        query.setFirstResult(0);//每页第一条数据的索引
        query.setMaxResults(5);//每页显示多少条数据。
        List<User> resultList = query.getResultList();
        for (User user : resultList) {
            System.out.println(user);
        }
        //transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    /*记录总条数*/
    @Test
    public void testFindAllCount() {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        // EntityTransaction transaction = entityManager.getTransaction();
        //transaction.begin();
        //sql select count(*) from user
        //String jqpl = "select count(id) from User ";
        String jqpl = "select count(id) from User ";
        Query query = entityManager.createQuery(jqpl);

        Object result = query.getSingleResult();
        System.out.println(result);
        //transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    /*模糊查询*/
    @Test
    public void testFindAllByUserName() {
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        // EntityTransaction transaction = entityManager.getTransaction();
        //transaction.begin();
        //sql select * from user where username like %zhang%
        //String jqpl = "select count(id) from User ";
        String jqpl = "from User where userName like ?";
        Query query = entityManager.createQuery(jqpl);
        //第一个参数只的是第几个？，第二个参数 值
        query.setParameter(1,"%zhang%");
        List<User> resultList = query.getResultList();
        for (User user : resultList) {
            System.out.println(user);
        }
        //transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值