SpringData

最新推荐文章于 2024-05-31 11:42:39 发布

明了LM

最新推荐文章于 2024-05-31 11:42:39 发布

阅读量67

点赞数

分类专栏： Spring 文章标签： spring

本文链接：https://blog.csdn.net/qq_29445811/article/details/112599975

版权

Spring 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

一、SpringData概述
二、搭建环境
三.Repository接口
四、Query注解
五、@Modifying 注解和事务
六、自定义 Repository 方法

一、SpringData概述

spring的一个子项目，用于简化数据库访问，支持NOSQL和关系型数据库。其主要目标是使数据库的访问变得方便快捷

SpringData项目支持NoSQL存储：MongoDB文档数据库、Neo4j图形数据库、Redis键值存储、HBASE列族数据库

SpringData所支持的关系数据存储技术：JDBC、JPA

二、搭建环境

<?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>groupId</groupId>
    <artifactId>JPA_PRO</artifactId>
    <version>1.0-SNAPSHOT</version>
       
    <dependencies>
        <!-- hibernate的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.1.Final</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.4.1.Final</version>
        </dependency>
        <!-- SpringData的支持包 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.29</version>
        </dependency>
    </dependencies>
</project>

<?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"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<!-- 配置自动扫描的包 -->
	<context:component-scan base-package="com.ming.entity"></context:component-scan>

	<!-- 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 -->
	<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.ming"></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>

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

	<!-- 4. 配置支持注解的事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

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

</beans>

package com.ming.entity;

import com.ming.entity.Person;
import org.springframework.data.repository.Repository;

/**
 * Repository<实体类，注解类型>
 */
public interface PersonRepository extends Repository<Person,Integer> {

    //根据名字获取Person
    Person getByLastName(String lastName);
}

package com.ming.db;

import com.ming.entity.Person;
import com.ming.entity.PersonRepository;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.sql.DataSource;
import java.sql.SQLException;

public class DataSourceTest {
    private ApplicationContext context = null;
     {
        context = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    /**
     * 测试EntityManagerFactory
     */
    @Test
    public void testJpa(){

    }

    @Test
    public void dbTest() throws SQLException {
        DataSource dataSource = context.getBean(DataSource.class);
        System.out.println(dataSource.getConnection());
    }

    @Test
     public void personJpaTest(){
        PersonRepository personRepository = context.getBean(PersonRepository.class);
        Person p = personRepository.getByLastName("tom");
        System.out.println(p);
     }
}

三.Repository接口

1. Repository接口

Repository是一个空接口，是一个标记接口

若我们定义的接口继承了Repository，则该接口会被IOC容器识别为一个Repository Bean 纳入到IOC容器中，进而可以在该接口中定义满足一定规范的方法。

与继承 Repository 等价的一种方式，就是在持久层接口上使用 @RepositoryDefinition 注解，并为其指定 domainClass 和 idClass 属性。

/**
 * Repository<实体类，注解类型>
 */
@RepositoryDefinition(domainClass = Person.class, idClass =Integer.class)
public interface PersonRepository /*extends Repository<Person,Integer> */{

    //根据名字获取Person
    Person getByLastName(String lastName);
}

2.Repository子接口

Repository：仅仅是一个标识，表明任何继承它的均为仓库接口类

CrudRepository：继承 Repository，实现了一组 CRUD 相关的方法

PagingAndSortingRepository：继承 CrudRepository，实现了一组分页排序相关的方法

JpaRepository：继承 PagingAndSortingRepository，实现一组 JPA 规范相关的方法

自定义的 XxxxRepository 需要继承 JpaRepository，这样的 XxxxRepository 接口就具备了通用的数据访问控制层的能力。

JpaSpecificationExecutor：不属于Repository体系，实现一组 JPA Criteria 查询相关的方法

3.Repository查询方法定义规范

简单条件查询: 查询某一个实体类或者集合

按照 Spring Data 的规范，查询方法以 find | read | get 开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写。

支持属性的级联查询。如当前类有符合条件的属性，优先使用。而不使用级联属性。若需要使用级联属性，则属性之间使用下划线连接

四、Query注解

这种查询可以声明在 Repository 方法中，摆脱像命名查询那样的约束，将查询直接在相应的接口方法中声明，结构更为清晰，这是 Spring data 的特有实现。

索引参数如下所示，索引值从1开始，查询中 ”?X” 个数需要与方法定义的参数个数相一致，并且顺序也要一致

命名参数（推荐使用这种方式）：可以定义好参数名，赋值时采用@Param(“参数名”)，而不用管顺序。

还可以使用@Query来指定本地查询，只要设置nativeQuery为true

	//查询 id 值最大的那个 Person
	//使用 @Query 注解可以自定义 JPQL 语句以实现更灵活的查询
	@Query("SELECT p FROM Person p WHERE p.id = (SELECT max(p2.id) FROM Person p2)")
	Person getMaxIdPerson();
	
	//为 @Query 注解传递参数的方式1: 使用占位符. 
	@Query("SELECT p FROM Person p WHERE p.lastName = ?1 AND p.email = ?2")
	List<Person> testQueryAnnotationParams1(String lastName, String email);
	
	//为 @Query 注解传递参数的方式1: 命名参数的方式. 
	@Query("SELECT p FROM Person p WHERE p.lastName = :lastName AND p.email = :email")
	List<Person> testQueryAnnotationParams2(@Param("email") String email, @Param("lastName") String lastName);
		//SpringData 允许在占位符上添加 %%. 
	@Query("SELECT p FROM Person p WHERE p.lastName LIKE %?1% OR p.email LIKE %?2%")
	List<Person> testQueryAnnotationLikeParam(String lastName, String email);
	
	//SpringData 允许在占位符上添加 %%. 
	@Query("SELECT p FROM Person p WHERE p.lastName LIKE %:lastName% OR p.email LIKE %:email%")
	List<Person> testQueryAnnotationLikeParam2(@Param("email") String email, @Param("lastName") String lastName);
	
	//设置 nativeQuery=true 即可以使用原生的 SQL 查询
	@Query(value="SELECT count(id) FROM jpa_persons", nativeQuery=true)
	long getTotalCount();

五、@Modifying 注解和事务

Spring Data 提供了默认的事务处理方式，即所有的查询均声明为只读事务。

对于自定义的方法，如需改变 Spring Data 提供的事务默认方式，可以在方法上注解 @Transactional 声明

进行多个 Repository 操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，需要在 Service 层实现对多个 Repository 的调用，并在相应的方法上声明事务。

	//可以通过自定义的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支持使用 INSERT
	//在 @Query 注解中编写 JPQL 语句, 但必须使用 @Modifying 进行修饰. 以通知 SpringData, 这是一个 UPDATE 或 DELETE 操作
	//UPDATE 或 DELETE 操作需要使用事务, 此时需要定义 Service 层. 在 Service 层的方法上添加事务操作. 
	//默认情况下, SpringData 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作!
	@Modifying
	@Query("UPDATE Person p SET p.email = :email WHERE id = :id")
	void updatePersonEmail(@Param("id") Integer id, @Param("email") String email);

六、自定义 Repository 方法

声明一个接口, 在该接口中声明需要自定义的方法, 且该接口需要继承 Spring Data 的 Repository.

提供所声明的接口的实现类. 且继承 SimpleJpaRepository, 并提供方法的实现

定义 JpaRepositoryFactoryBean 的实现类, 使其生成定义的接口实现类的对象

修改 < jpa:repositories /> 节点的 factory-class 属性指向 3) 的全类名

注意: 全局的扩展实现类不要用 Imp 作为后缀名, 或为全局扩展接口添加 @NoRepositoryBean 注解告知 Spring Data: Spring Data 不把其作为 Repository

明了LM

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringData

文章目录一、SpringData概述二、使用步骤1.引入库2.读入数据总结一、SpringData概述spring的一个子项目，用于简化数据库访问，支持NOSQL和关系型数据库。其主要目标是使数据库的访问变得方便快捷SpringData项目支持NoSQL存储：MongoDB文档数据库、Neo4j图形数据库、Redis键值存储、HBASE列族数据库SpringData所支持的关系数据存储技术：JDBC、JPA二、使用步骤1.引入库代码如下（示例）：import numpy as npimpo
复制链接

扫一扫