spring data jpa学习笔记一:helloworld

在学习 JPA Spring Data之前，我们有必要了解一下JPA和Spring Data。

JPA

JPA全称Java Persistence API。即java持久化规范。JPA通过注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

Spring Data

Spring Data是Spring框架的一个子项目，就像Spring MVC是Spring的一部分一样。使得数据库访问变得方便和快捷。Spring Data 支持JPA。

JPA Spring Data

JPA Spring Data致力于减少数据访问层(DAO)的开发量。使用Spring Data JPA,开发人员只需要声明持久层的接口。

JPA Spring Data与JPA的关系

JPA Spring Data是JPA规范的一种上层实现。

下面我们通过一个简单的Hello World案例来学习Spring Data JPA的相关技术。

使用 Spring Data JPA 进行持久层开发需要的四个步骤：

第一步：配置 Spring 整合 JPA

第二步：在 Spring 配置文件中配置 Spring Data，让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

第三步：声明持久层的接口，该接口继承 Repository，Repository 是一个标记型接口，它不包含任何方法，如必要，Spring Data 可实现 Repository 其他子接口，其中定义了一些常用的增删改查，以及分页相关的方法。

第四步：在接口中声明需要的方法。Spring Data 将根据给定的策略（具体策略稍后讲解）来为其生成实现代码。

第一步的具体过程如下：

第一步：新建一个java工程命名为springDataJpa

第二步：在工程下新建libs文件夹，用来存放外部jar包

第三步：引入jar包

spring框架相关jar包：　　　　　　　　　　　　　　hibernate相关jar包　　　　　　　　　　　　　　　　　　　　jpa相关jar包

　　　　　　　　　　　　　　　　

c3p0相关jar包：　　　　　　　　　　　　　　　　　mysql驱动包

　　　　　　　　

　　　　　　　　　

将上面的jar包拷入第二步中新建的libs文件夹中，右键-->构建路径-->添加至构建路径,将jar包加入到classpath下。

第四步：新建spring配置文件，命名为applicationContext.xml

在配置文件中配置：数据源、JPA 的EntityManagerFactory、spring事务管理器、支持注解的事务、Spring Data

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

    <!-- 1. 配置数据源 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="driverClass" value="${jdbc.driverClass}"></property>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>

        <!-- 配置其他属性 -->
    </bean>

    <!-- 2. 配置 JPA 的 EntityManagerFactory -->

    <!-- 3. 配置事务管理器 -->

    <!-- 4. 配置支持注解的事务 -->

    <!-- 5. 配置 SpringData -->

</beans>

第五步：新建db.properties文件，里面用key-value形式存储数据源相关信息

db.properties

jdbc.user=root
jdbc.password=mysql
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///jpa

此处使用的是mysql数据库，我们需要根据各自环境来配置自己的用户名、密码和url这些信息。

到这一步的时候，我们可以先进行一下单元测试，看看之前的配置是否存在问题。

第六步：新建SpringDataTest测试类

SpringDataTest.java

package com.springdata.jpa.test;

import java.sql.SQLException;

import javax.sql.DataSource;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDataTest {

    private ApplicationContext ctx = null;

    {
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    /**
     * 测试数据源配置是否正确
     * @throws SQLException
     */
    @Test
    public void testSpringData() throws SQLException {
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource.getConnection());
    }

}

如果控制台打印如下信息

则说明测试成功

测试成功之后，我们需要继续在applicationContext.xml中配置JPA 的 EntityManagerFactory

<!-- 2. 配置 JPA 的 EntityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
        </property>
        <property name="packagesToScan" value="com.springdata.jpa"></property>
        <property name="jpaProperties">
            <props>
                <!-- 二级缓存相关 -->
                <!--
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
                <prop key="net.sf.ehcache.configurationResourceName">ehcache-hibernate.xml</prop>
                -->
                <!-- 生成的数据表的列的映射策略 -->
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <!-- hibernate 基本属性 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

配置玩EntityManagerFactory后，我们可以建一个Person类来验证一下，配置是否正确

Person.java

package com.springdata.jpa.entity;

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name="JPA_PERSONS")
@Entity
public class Person {
    private Integer id;
    private String lastName;

    private String email;
    private Date birth;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public Date getBirth() {
        return birth;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    } 

}

测试:在SpringDataTest测试类中添加tespJpa方法

@Test
public void testJpa(){

}

以junit方式运行testJpa方法，运行之后查看数据库中是否生成了jpa_persons表，如果有则配置成功，可以继续下一步。

下面的图片中是jpa_persons表结构

接下来我们需要继续在applicationContext.xml中配置事务管理器和支持注解的事务

<!-- 3. 配置事务管理器 -->
    <bean id="transactionManager"
        class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
    </bean>

    <!-- 4. 配置支持注解的事务 -->
    <!-- 此处transaction-manager属性值与事务管理器的bean的id保持一致 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

到这里，Spring 整合 JPA这一步就结束了。

接下来我们开始配置第二步：在 Spring 配置文件中配置 Spring Data

过程如下：

第一步：引入spring data 相关jar包

将上面的jar包拷入第二步中新建的libs文件夹中，右键-->构建路径-->添加至构建路径,将jar包加入到classpath下。

第二步：在applicationContext.xml中配置SpringData

<!-- 5. 配置 SpringData -->
<!-- 加入  jpa 的命名空间 -->
<!-- base-package: 扫描 Repository Bean 所在的 package -->
<jpa:repositories base-package="com.springdata.jpa"
    entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

第三步：创建PersonRepository接口来测试一下配置是否正确

package com.springdata.jpa.repository;

import org.springframework.data.repository.Repository;

import com.springdata.jpa.entity.Person;

public interface PersonRepository extends Repository<Person, Integer>{
    //根据 lastName 来获取对应的 Person
    Person getByLastName(String lastName);
}

在测试之前我们需要先向数据库表jpa_persons中插入一条数据，例如：

然后在在SpringDataTest测试类中添加testGetByLastName方法

@Test
public void testGetByLastName(){
    PersonRepository personRepository = ctx.getBean(PersonRepository.class);
    Person person = personRepository.getByLastName("AA");
    System.out.println(person);
}

以junit方式运行testGetByLastName方法，发现报了如下错误：

Caused by: java.lang.ClassNotFoundException: org.slf4j.LoggerFactory
    at java.net.URLClassLoader$1.run(URLClassLoader.java:366)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:425)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:358)
    ... 46 more

原因是Spring Data依赖slf4j的jar包，所以我们还需要引入如下jar包，并将其加入classpath下

再次以junit方式运行testGetByLastName方法，控制台打印消息如下：

到此为止，在 Spring 配置文件中配置 Spring Data这一步也完成了。

利用第一个小程序helloworld的搭建到此也就完成了。

此博文是观看尚硅谷的jpa教学视频后所做学习笔记，如果有博友需要这套视频，可以访问如下网址进行下载：

http://pan.baidu.com/s/1DJHIe

时间： 2025-01-30 16:32:42

spring data jpa学习笔记一:helloworld的相关文章

Spring Data JPA学习笔记

Spring Data是一个用于简化数据库访问,并支持云服务的开源框架,其主要目标是使得对数据的访问变得方便快捷.可以在几乎不用写实现的情况下,实现对数据的访问和操作.除了CRUD外,还包括如分页.排序等一些常用的功能. Spring Data JPA提供的接口:1:Repository:最顶层的接口,是一个空的接口,目的是为了统一所有Repository的类型,且能让组件扫描的时候自动识别.2:CrudRepository :是Repository的子接口,提供CRUD的功能.3:Paging

[Spring Data MongoDB]学习笔记－－建立数据库的连接

1. 有了上一篇的Mongo后,连接数据库我们还需要更多的信息,比如数据库名字,用户名和密码等. 我们可以继续来配置MongoDbFactory的实例. public interface MongoDbFactory { DB getDb() throws DataAccessException; DB getDb(String dbName) throws DataAccessException; } 然后我们可以继续用MongoDbFactory来创建MongoTemplate的实例. pu

[Spring Data MongoDB]学习笔记－－牛逼的MongoTemplate

MongoTemplate是数据库和代码之间的接口,对数据库的操作都在它里面. 注:MongoTemplate是线程安全的. MongoTemplate实现了interface MongoOperations,一般推荐使用MongoOperations来进行相关的操作. MongoOperations mongoOps = new MongoTemplate(new SimpleMongoDbFactory(new Mongo(), "database")); MongoDB docu

[Spring Data MongoDB]学习笔记－－注册一个Mongo实例

1. 通过Java based bean metadata @Configuration public class AppConfig { public @Bean Mongo mongo() throws UnknownHostExceptioin { return new Mongo("localhost"); } } 上面的方式包含异常处理,这并不是我们想要的. 所以,应该尽量用下面这种方式MongoFactoryBean,或者后面的xml方式. @Configuration p

[Spring Data MongoDB]学习笔记－－_id和类型映射

_id字段的映射: MongoDB要求所有的document都要有一个_id的字段. 如果我们在使用中没有传入_id字段,它会自己创建一个ObjectId. { "_id" : ObjectId("53e0ff0b0364cb4a98ce3bfd"), "_class" : "org.springframework.data.mongodb.examples.hello.domain.Person", "name&q

[Spring Data MongoDB]学习笔记－－MapReduce

mongodb的MapReduce主要包含两个方法:map和reduce. 举个例子,假设现在有下面3条记录 { "_id" : ObjectId("4e5ff893c0277826074ec533"), "x" : [ "a", "b" ] } { "_id" : ObjectId("4e5ff893c0277826074ec534"), "x"

[Spring Data MongoDB]学习笔记－－MongoTemplate插入修改操作

插入操作: 直接给个例子 import static org.springframework.data.mongodb.core.query.Criteria.where; import static org.springframework.data.mongodb.core.query.Criteria.query; … Person p = new Person("Bob", 33); mongoTemplate.insert(p);//还可以多加一个参数,来提供collectio

[Spring Data MongoDB]学习笔记－－MongoTemplate查询操作

查询操作主要用到两个类:Query, Criteria 所有的find方法都需要一个query的object. 1. 直接通过json来查找,不过这种方式在代码中是不推荐的. BasicQuery query = new BasicQuery("{ age : { $lt : 50 }, accounts.balance : { $gt : 1000.00 }}"); List<Person> result = mongoTemplate.find(query, Perso

Spring入门---JPA学习笔记

用了一段时间的Spring,到现在也只是处于会用的状态,对于深入一点的东西都不太了解.所以决定开始深入学习Spring. 本文主要记录JPA学习.在学习JPA之前,需要了解一些ORM的概念. ORM概念: 对象关系映射ORM(Object/Relation Mapping)是一种为了解决面向对象和关系数据之间存在互不匹配现象的技术(范式不匹配).简而言之,ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到数据库中.本质上是将数据从一种形式转换到另外一种形式.(个人考虑: