使用JPA为应用添加持久层

最新推荐文章于 2024-04-30 14:39:37 发布
最新推荐文章于 2024-04-30 14:39:37 发布
阅读量810 收藏
点赞数
分类专栏： CP 文章标签： CP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jiang_kunyou/article/details/82312921
版权

使用JPA为应用添加持久层

第一步：创建基类
让我们首先为我们的域模型创建一个基类。这通重点内容常被认为是最佳实践，因为它为我们提供了一个中心位置，可以在以后添加要在所有域模型对象之间共享的通用功能。为此，从项目的上下文菜单项中选择New> Class，weatherapp并提供以下详细信息：
• 包名： com.sap.hana.cloud.samples.weatherapp.model
• 类名： BaseObject

这里写图片描述
第二步：替换代码
该代码就是BaseObject的内容

package com.sap.hana.cloud.samples.weatherapp.model;
import java.util.Date;
import java.util.UUID;
import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
/**
 * Base class for all domain model objects.
 */
@MappedSuperclass
public abstract class BaseObject 
{
    /**
     * The (globally unique) ID of the object.
     */
    @Id
    @Column(name="GUID", length = 36)
    private String guid = UUID.randomUUID().toString();
/**
     * The {@link Date} the object was created at.
     */
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name="CREATION_DATE", updatable = false)
    private Date createdAt = null;

    /**
     * The {@link Date} the object was last modified at.
     */
    @Temporal(TemporalType.TIMESTAMP)
    @Column(name="MODIFICATION_DATE")
    private Date lastModifiedAt = null;
/**
     * ID of the user who created the object.
     */
    @Column(name="CREATED_BY", updatable = false, length = 20)
    private String createdBy = null;

    /**
     * ID of the user who was the last to modify the object.
     */
    @Column(name="MODIFIED_BY", length = 20)
    private String lastModifiedBy = null;

    /**
     * Life-cycle event callback, which automatically sets the last modification date.  
     */
    @PreUpdate
    protected void updateAuditInformation() 
    {
        lastModifiedAt = new Date();

        // TODO - obtain currently logged-on user
    }
/**
     * Life-cycle event callback, which automatically creates a unique ID for the object
     * and populates its audit information.  
     */
    @PrePersist
    protected void generateAuditInformation() 
    {   
        final Date now = new Date();

        createdAt = now;
        lastModifiedAt = now;

        // TODO - obtain currently logged-on user
    }
public String getGuid()
    {
        return this.guid;
    }
public void setGuid(String guid)
    {
        this.guid = guid;
    }

    public Date getCreatedAt()
    {
        return this.createdAt;
    }
public void setCreatedAt(Date createdAt)
    {
        this.createdAt = createdAt;
    }
public Date getLastModifiedAt()
    {
        return this.lastModifiedAt;
    }
public void setLastModifiedAt(Date lastModifiedAt)
    {
        this.lastModifiedAt = lastModifiedAt;
    }
public String getCreatedBy()
    {
        return this.createdBy;
    }
public void setCreatedBy(String createdBy)
    {
        this.createdBy = createdBy;
    }
public String getLastModifiedBy()
    {
        return this.lastModifiedBy;
    }
public void setLastModifiedBy(String lastModifiedBy)
    {
        this.lastModifiedBy = lastModifiedBy;
    }
}

–第三步：创建另一个Java类
接下来，FavoriteCity.java使用相同的过程创建另一个Java类（）：
• 包名： com.sap.hana.cloud.samples.weatherapp.model
类名： FavoriteCity
这里写图片描述
替换该类的代码

package com.sap.hana.cloud.samples.weatherapp.model;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
/**
 * Model object representing a single {@link FavoriteCity} instance.
 * 
 * @author Matthias Steiner
 * @version 0.1
 */
@Entity
@Table(name = "WEATHERAPP_CITY")
@NamedQueries({@NamedQuery(name = "FavoriteCities", query = "SELECT c FROM FavoriteCity c"), 
               @NamedQuery(name = "FavoriteCityById", query = "SELECT c FROM FavoriteCity c WHERE c.id = :id")})
@XmlRootElement(name = "city")
@XmlAccessorType(XmlAccessType.FIELD)
public class FavoriteCity extends BaseObject implements Serializable
{
    /**
     * The <code>serialVersionUID</code> of the {@link FavoriteCity} class.
     */
    private static final long serialVersionUID = 1L;
@Column(name="ID", length = 36, nullable=true)
    String id = null;

    @Column(name="NAME", length = 128, nullable=true)
    String name = null;

    @Column(name="COUNTRY", length = 2, nullable=true)
    String countryCode = null;
public String getId()
    {
        return id;
    }

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

    public String getName() 
    {
        return name;
    }
public void setName(String name) 
    {
        this.name = name;
    }
public String getCountryCode() 
    {
        return countryCode;
    }
public void setCountryCode(String countryCode) 
    {
        this.countryCode = countryCode;
    }
}

第四步：创建配置文件
接下来，我们需要为持久层创建配置文件。根据Maven约定，这些非源代码工件应位于名为的单独源代码文件夹中：src/main/resources。因此，让我们通过Project Explorer中Java Resources节点上相应的上下文菜单条目创建该源文件夹：New> Source Folder。提供以下信息：
• 项目名： weatherapp
• 文件夹名称： src/main/resources
这里写图片描述
第五步：创建文件夹
打开此新创建的源文件夹的上下文菜单，然后选择“ 新建”>“其他”选项，然后选择“ 文件夹”选项。命名新文件夹META-INF（所有大写！），然后单击“ 完成”。
第六步：创建持久性xml文件
打开新创建的META-INF文件夹的上下文菜单，然后选择“ 新建”>“文件”。命名新文件persistence.xml，然后单击“ 完成”。
这里写图片描述
将以下XML内容复制并粘贴到persistence.xml文件中：

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
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">

<persistence-unit name="application" transaction-type="RESOURCE_LOCAL">
<provider>
    org.eclipse.persistence.jpa.PersistenceProvider
</provider>
<class>
    com.sap.hana.cloud.samples.weatherapp.model.BaseObject
</class>
<class>
    com.sap.hana.cloud.samples.weatherapp.model.FavoriteCity
</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
      <property name="eclipselink.ddl-generation" value="create-tables"/>
  </properties>
</persistence-unit>
</persistence>

第七步：添加依赖项
接下来，我们需要为我们的pom.xml文件添加更多依赖项。在这种情况下，最重要的依赖是EclipseLink（我们选择的JPA实现）。但是，我们还需要声明Derby DB和Jackson的依赖关系（将数据转换为JSON所需的序列化框架，反之亦然。）
复制代码

<!-- EclipseLink (and JPA) -->
<dependency>
  <groupId>org.eclipse.persistence</groupId>
  <artifactId>eclipselink</artifactId>
  <version>2.5.0</version>
  </dependency>
<dependency>
   <groupId>org.eclipse.persistence</groupId>
   <artifactId>javax.persistence</artifactId>
   <version>2.1.0</version>
 </dependency>
 <!-- Derby -->
<dependency>
<groupId>org.apache.derby</groupId>
  <artifactId>derbyclient</artifactId>
  <version>10.9.1.0</version>
</dependency>
<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
<version>10.9.1.0</version>
</dependency>

<dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>javax.ws.rs-api</artifactId>
<version>2.0</version>
</dependency>

<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-jaxrs</artifactId>
<version>${org.codehaus.jackson-version}</version>
</dependency>

我们还需要将Jackson版本作为属性添加到pom.xml文件的属性部分（正如我们在上一节中所做的那样）并保存您的更改

<org.codehaus.jackson-version>1.9.9</org.codehaus.jackson-version>

这里写图片描述
第八步：创建CRUD服务
下一步是创建相应的CRUD服务。为此，请创建一个包含以下详细信息的新类：
• 包名： com.sap.hana.cloud.samples.weatherapp.api
• 类名： FavoriteCityService
该类的代码内容

package com.sap.hana.cloud.samples.weatherapp.api;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.sql.DataSource;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.SecurityContext;
import org.eclipse.persistence.config.PersistenceUnitProperties;
import com.sap.hana.cloud.samples.weatherapp.model.FavoriteCity;
/**
 * {@link FavoriteCityService}
 * 
 * @author Matthias Steiner
 * @version 0.1
 */
@Path("/cities")
@Produces({ MediaType.APPLICATION_JSON })
public class FavoriteCityService 
{
    @SuppressWarnings("unchecked")
    @GET
    @Path("/")
    public List<FavoriteCity> getFavoriteCities()
    {
        List<FavoriteCity> retVal = null;

        EntityManager em = this.getEntityManagerFactory().createEntityManager();
retVal = em.createNamedQuery("FavoriteCities").getResultList();

        return retVal;
    }

    @GET
    @Path("/{id}")
    public FavoriteCity getFavoriteCity(@PathParam(value = "id") String id)
    {
        FavoriteCity retVal = null;

        EntityManager em = this.getEntityManagerFactory().createEntityManager();

        try
        {
            Query query = em.createNamedQuery("FavoriteCityById");
            query.setParameter("id", id);
            retVal = (FavoriteCity) query.getSingleResult();
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            em.close();
        }

        return retVal;
    }

    @SuppressWarnings("unchecked")
    @POST
    @Path("/")
    public List<FavoriteCity> addFavoriteCity(FavoriteCity city)
    {
        List<FavoriteCity> retVal = null;

        EntityManager em = this.getEntityManagerFactory().createEntityManager();

        try
        {
            em.getTransaction().begin();
            em.persist(city);
            em.getTransaction().commit();

            retVal = em.createNamedQuery("FavoriteCities").getResultList();
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            em.close();
        }

        return retVal;
    }

    @SuppressWarnings("unchecked")
    @DELETE
    @Path("/{id}")
    public List<FavoriteCity> removeFavoriteCity(@PathParam(value = "id") String id)
    {
        List<FavoriteCity> retVal = null;

        EntityManager em = this.getEntityManagerFactory().createEntityManager();

        try
        {
            Query query = em.createNamedQuery("FavoriteCityById");
            query.setParameter("id", id);
            FavoriteCity city = (FavoriteCity) query.getSingleResult();

            if (city != null)
            {
                em.getTransaction().begin();
                em.remove(city);
                em.getTransaction().commit();
            }

            retVal = em.createNamedQuery("FavoriteCities").getResultList();
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            em.close();
        }

        return retVal;
    }


    /**
     * Returns the <code>DefaultDB</code> {@link DataSource} via JNDI.
     * 
     * @return <code>DefaultDB</code> {@link DataSource}
     */
    protected DataSource getDataSource()
    {
        DataSource retVal = null;

        try 
        {
            InitialContext ctx = new InitialContext();
            retVal = (DataSource) ctx.lookup("java:comp/env/jdbc/DefaultDB");
        }
        catch (NamingException ex)
        {
            ex.printStackTrace();
        }

        return retVal;
    }

    /**
     * Returns the {@link EntityManagerFactory}.
     * 
     * @return The {@link EntityManagerFactory}
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    protected EntityManagerFactory getEntityManagerFactory()
    {
        EntityManagerFactory retVal = null;

        try
        {
            Map properties = new HashMap();

            DataSource ds = this.getDataSource();

            properties.put(PersistenceUnitProperties.NON_JTA_DATASOURCE, ds);

            retVal = Persistence.createEntityManagerFactory("application", properties);
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }

        return retVal;
    }

}

第九步：创建REST服务
要在web.xml配置文件中注册我们的RESTful服务实现，请将我们FavoriteCityService类的完全限定类名添加到逗号分隔列表中jaxrs.serviceClasses。请参阅下面的代码段，了解在元素中输入完全限定类名的位置（不要忘记AuthenticationService行尾的逗号）。

<init-param>
    <param-name>jaxrs.serviceClasses</param-name>
    <param-value>
    com.sap.hana.cloud.samples.weatherapp.api.AuthenticationService,
    com.sap.hana.cloud.samples.weatherapp.api.FavoriteCityService
    </param-value>
</init-param>

这里写图片描述

第十步：为json反序列化添加初始化参数。
在上述标记的下方，我们需要为JSON反序列化添加另一个标记，如下所示：

<init-param>
    <param-name>jaxrs.providers</param-name>
    <param-value>org.codehaus.jackson.jaxrs.JacksonJsonProvider</param-value>
</init-param>

这里写图片描述
第十一步：定义数据源
要做的最后一个更改是在其中定义一个DataSource web.xml以便连接到底层数据库。为此，请在结束标记之后复制并粘贴以下XML代码段：

<resource-ref>
<res-ref-name>jdbc/DefaultDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
</resource-ref>

这里写图片描述
第十二步：REST工具
为了正确测试我们的RESTful服务，我们需要一个REST工具（例如Postman），它允许您以方便的方式执行HTTP调用。
在邮递员中，输入http://localhost:8080/weatherapp/api/v1/citiesURL输入字段，并确保Basic Auth在“ 授权”选项卡中提供您的用户名/密码作为参数。
然后，确保按相应的更新请求按钮更新请求。然后，将“Authorization”参数作为HTTP标头参数添加到您的请求中。
这里写图片描述
执行调用后，您将在成功验证后看到两个空括号“[]”（表示空数组）。别担心，我们还没有将任何城市保存为最爱，所以这正是我们所期望的

这里写图片描述
至此，我们对于SAP Cloud PlatForm中的使用JPA为应用添加持久层部分已经完成了。

Jiang_kunyou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA持久层规范 -- JPA demo
08-25
一个非常简单易懂的 JPA 例子，帮你快速入门JPA
持久层方案SpringDataJPA文件及配置
03-10
本资源包包含了关于SpringDataJPA的详细配置和文档，旨在帮助你快速理解和应用这个持久层解决方案。 **1. SpringDataJPA介绍** SpringDataJPA是Spring框架的扩展，它简化了数据库操作，通过提供一种声明式的方式来...
JPA作持久层操作
不吃紫菜的博客
08-05 338
JPA(Hibernate是jpa的实现) jpa是对实体类操作，从而通过封装好的接口直接设置数据库的表结构。虽然jpa可以直接通过编写java代码来操作数据库表结构，避免了sql的编写，但别忘了需要先建立jpa需要操作的数据库并更改配置文件到该数据库，jpa不能建库！！！ 国外比较流行jpa，国内更加流行mybatis，因为mybatis直接操作数据库容易懂和后期维护一点。(其实是国内程序...
Spring Data JPA数据批量插入、批量更新真的用对了吗
最新发布
JingAi_jia917的博客
04-30 3124
本文从源码角度分析了saveAll()批量操作批处理方法，并非理想中的数据库批量操作。并分享了Mysql和Oracle数据库批量更新数据库的方法。
持久层框架：JPA
Junnix的博客
04-08 2613
持久层框架：JPA 优点：全自动生成SQL语句和DB 缺点：后期优化不方便 一：基本使用 1. 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> 2. 配置yml文件 spring: jpa: #开启SQ
Spring Data JPA 持久层开发
bitree1的博客
11-24 1309
下面总结一下使用 Spring Data JPA 进行持久层开发大致需要的三个步骤： 声明持久层的接口，该接口继承 Repository，Repository 是一个标记型接口，它不包含任何方法，当然如果有需要，Spring Data 也提供了若干 Repository 子接口，其中定义了一些常用的增删改查，以及分页相关的方法。 在接口中声明需要的业务方法。Spring Data 将根据给定的...
Spring Data JPA的持久层
最佳 Java 编程
05-06 437
1.概述 本文将重点介绍Spring 3.1，JPA和Spring Data的持久层的配置和实现。 有关使用基于Java的配置和项目的基本Maven pom设置Spring上下文的分步介绍，请参阅本文 。 持久性与春天 系列 ： 第1部分 – 具有Spring 3.1和Hibernate的持久层 第2部分 – 使用Spring和Java泛型简化数据访问层 第3部分 – 具有...
SpringBoot整合持久层技术之搭建并整合Spring Data JPA项目
06-17
SpringBoot整合Spring Data JPA是现代Java开发中的常见实践，它极大地简化了数据库操作，让开发者可以更加专注于业务逻辑而不是繁琐的数据访问层实现。本文将详细介绍如何使用Spring Boot搭建一个基于Spring Data ...
EJB_JPA数据库持久层开发详解.doc
10-15
在本章节，我们将深入探讨JPA的相关概念、发展历程以及其在数据库持久层开发中的应用。 1. 数据持久化概述 数据持久化是指将程序运行过程中的数据保存到长期存储介质，如硬盘或数据库中，以便在程序关闭或系统重启...
krush：Kotlin的惯用持久层
01-30
"krush"是一个专为Kotlin设计的轻量级持久层框架，它旨在提供一种惯用（idiomatic）的方式来与SQL数据库进行交互，从而简化Kotlin应用的数据库管理。 krush利用了Kotlin的强大特性和类型安全，使得SQL查询更加直观...
jpa（hibernate 持久层）所需要的jar包
10-17
在使用JPA和Hibernate进行开发时，我们需要一些特定的**jar包**来支持我们的应用程序。这些jar包通常包括以下几个关键部分： 1. **JPA规范**：包含`javax.persistence-api.jar`，这是JPA的官方API，定义了持久化...
JPA-持久层工具
xiaoguaihu12的博客
09-16 228
https://www.jianshu.com/p/1fb00955302a?tdsourcetag=s_pcqq_aiomsg 可以代替H和M, 与spring全家桶整合 同时, 使用JPA时, 需要在实体类上添加几个注解: 注解在类上: @Entity //表示这个类是一个实体类，对应数据库中的一个表 @Table(name = "tb_name") ...
JPA 持久层框架的初学笔记
gz_blog
07-02 1087
文章目录why?what？how？1. 基础部件介绍2. 数据库结构3. jpa的jar包依赖配置（Maven）4. JPA的配置5. 实体类6. DAO接口7. 测试代码完整项目 why? JPA的作用类似于MyBatis，但更加的自动化，在对数据库性能要求不是特别高的时候很方便。 可以避免繁复的JDBC数据库操作代码的编写，提高java持久层开发的效率。 what？ JPA(Java Pers...
SringBoot的持久层搭配-JPA
pb951028的博客
06-11 230
-可搭配SpringDataJpa（官方推荐） ---业界趋势-dao层只有接口没有实现 public interface XxRepository extends JpaRepository{ 虚方法1(); 虚方法2(); } Public class 上层类{ @Autowired XxRepository xxRepository; Pu...
SpringBoot实现持久层支持：JPA
龙套的博客
07-11 357
二、SpringBoot持久层支持 自学网站：How2java 1、JPA概念 ​ JPA(Java Persistence API)是Sun官方提出的Java持久化规范，用来方便大家操作数据库。 ​ 真正干活的可能是Hibernate,TopLink等等实现了JPA规范的不同厂商，默认是Hibernate。 2、JPA配置 创建数据库和表，准备数据 create database how2j...
spring-boot 集成jpa 持久层
jade的专栏
07-14 785
spring-boot 集成jpa 持久层说明 jpa 建议项目只做持久操作. 案列使用的mysql数据库 演示是基于第一个版本pom修改 <!--添加单元测试 begin --> <dependency> <groupId>org.springframework.boot</groupId> <artif
持久框架JPA
weixin_40159122的博客
02-19 261
1.什么是JPA？ 用于对象持久化的 API； JPA规范：JPA本质是一种ORM规范，不是ORM框架，因为JPA并未提供ORM实现，他只是定制一些规范，提供一些编程的API接口。 Hibernate是实现：Hibernate除了作为ORM框架以外，他是一种JPA实现； 功能上说：JPA是Hibernate功能的一个子集。 2.JPA优势 标准化：简单易用，集成方便；可以媲美JDBC的...
Hibernate注解详解
一个有趣、有料、有内涵的地方!
08-10 137
一实体Bean 每个持久化POJO类都是一个实体Bean,通过在类的定义中使用@Entity注解来进行声明。 声明实体Bean @Entity public...
关于SpringBoot的持久层的一些支持（JPA）
铛铛当的博客
07-25 1081
最近开始学习springboot，通过上网找资料和看视频学会了许多，下面就是博主的学习过程。。。 开发环境：jdk1.8、开发工具IDEA2016、Tomcat9.0.8，MySQL版本5.1.2     首先来说一下关于JPA，百度是这么说的： JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并...
Spring Boot 集成持久层及应用 试讲PPT
07-13
Spring Boot对持久层的支持非常丰富，可以轻松集成各种数据访问技术，包括JPA、Hibernate等。通过Spring Boot的自动配置和starter模块，可以简化数据库访问的配置和管理，使得持久层开发更加简单和高效。 在应用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值