Spring Data JPA教程第一部分：配置

最新推荐文章于 2022-10-14 11:31:36 发布
最新推荐文章于 2022-10-14 11:31:36 发布
阅读量204 收藏
点赞数
文章标签： java spring maven hibernate spring boot

Spring Data JPA是一个旨在简化基于JPA的存储库的创建并减少与数据库通信所需的代码量的项目。 在我的工作和个人爱好项目中，我已经使用了一段时间，确实使事情变得更加简单和整洁。 现在是时候与您分享我的知识了。

这是我的Spring Data JPA教程的第一部分，它将向您介绍在将Hibernate用作JPA提供程序时如何配置Spring Data JPA。 在开始之前，我想弄清楚一件事：本教程不是Hibernate，JPA或Spring的入门级教程。 如果您想了解我的Spring Data JPA教程中描述的概念，那么您必须对这些技术有一定的经验。

本教程的依赖性如下：

  • BoneCP 0.7.1.RELEASE（您也可以使用其他数据源实现）
  • Hibernate 4.0.1.Final
  • Spring Framework 3.1.0。发布
  • Spring Data JPA 1.0.2
  • Servlet API 3.0

另外，由于我将Maven用作构建工具，因此如果要运行示例应用程序，则必须安装它。

入门

现在该开始了。 您可以按照以下步骤配置Spring Data JPA：

  • 您必须获得所需的依赖关系。
  • 您必须在Spring应用程序上下文配置中配置所需的bean。 Spring Data JPA所需的bean是：数据源，事务管理器和实体管理器工厂。
  • 您必须配置Spring Data JPA。

以下将详细解释这些步骤：

获得所需的辅佐

首先，您需要获取所需的依赖关系。 您可以通过在pom.xml文件中配置所需的依赖项来实现。 我的示例的pom.xml看起来如下： 

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>net.petrikainulainen.spring</groupId>
    <artifactId>data-jpa-tutorial-part-one</artifactId>
    <packaging>war</packaging>
    <version>0.1</version>
    <name>Spring Data JPA Tutorial Part One</name>
    <description>Spring Data JPA Tutorial Part One</description>
    <licenses>
        <license>
            <name>Apache License 2.0</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0</url>
        </license>
    </licenses>
    <url>http://www.petrikainulainen.net</url>
    <repositories>
        <repository>
            <id>repository.jboss.org-public</id>
            <name>JBoss repository</name>
            <url>https://repository.jboss.org/nexus/content/groups/public</url>
        </repository>
    </repositories>
    <properties>
        <hibernate.version>4.0.1.Final</hibernate.version>
        <mysql.connector.version>5.1.18</mysql.connector.version>
        <slf4j.version>1.6.1</slf4j.version>
        <spring.version>3.1.0.RELEASE</spring.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <!-- Spring Framework -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring MVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>
        <!-- Spring Data JPA -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.0.2.RELEASE</version>
        </dependency>
        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- H2 Database -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.3.160</version>
        </dependency>
        <!-- MySQL JDBC connector -->
        <!-- If you want to use MySQL, uncomment this dependency declation. -->
        <!--
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>${mysql.connector.version}</version>
       </dependency>
       -->
        <!-- PostgreSQL JDBC 4 -->
        <!-- If you don't want to use PostgreSQL, uncomment this dependency declaration. -->
        <!--
       <dependency>
           <groupId>postgresql</groupId>
           <artifactId>postgresql</artifactId>
           <version>9.0-801.jdbc4</version>
       </dependency>
       -->
        <!-- BoneCP -->
        <dependency>
            <groupId>com.jolbox</groupId>
            <artifactId>bonecp</artifactId>
            <version>0.7.1.RELEASE</version>
        </dependency>
        <!-- Servlet API 3.0 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!-- Logging dependencies -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!-- Testing Dependencies -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>data-jpa-tutorial-part-one</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.1.1</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>8.1.0.RC2</version>
                <configuration>
                    <scanIntervalSeconds>0</scanIntervalSeconds>
                    <webAppConfig>
                        <defaultsDescriptor>src/main/resources/webdefault.xml</defaultsDescriptor>
                    </webAppConfig>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-site-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <reportPlugins>
                        <!-- Cobertura Plugin -->
                        <plugin>
                            <groupId>org.codehaus.mojo</groupId>
                            <artifactId>cobertura-maven-plugin</artifactId>
                            <version>2.5.1</version>
                        </plugin>
                    </reportPlugins>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

配置Spring应用程序上下文

其次，您必须配置Spring应用程序上下文。 您可能还记得，您需要配置数据源，事务管理器和实体管理器工厂bean。 如果您使用的是Spring 3.1和Servlet 3.0，则可以通过实现Java配置类并将该配置类加载到Web应用程序初始化程序中来实现。 我的应用程序上下文配置类的内容如下： 

import com.jolbox.bonecp.BoneCPDataSource;
import org.hibernate.ejb.HibernatePersistence;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.*;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.core.env.Environment;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

import javax.annotation.Resource;
import javax.sql.DataSource;

/**
 * An application context Java configuration class. The usage of Java configuration
 * requires Spring Framework 3.0 or higher with following exceptions:
 * <ul>
 *     <li>@EnableWebMvc annotation requires Spring Framework 3.1</li>
 * </ul>
 * @author Petri Kainulainen
 */
@Configuration
@ComponentScan(basePackages = {"net.petrikainulainen.spring.datajpa.controller"})
@EnableWebMvc
@ImportResource("classpath:applicationContext.xml")
@PropertySource("classpath:application.properties")
public class ApplicationContext {
   
    private static final String VIEW_RESOLVER_PREFIX = "/WEB-INF/jsp/";
    private static final String VIEW_RESOLVER_SUFFIX = ".jsp";

    private static final String PROPERTY_NAME_DATABASE_DRIVER = "db.driver";
    private static final String PROPERTY_NAME_DATABASE_PASSWORD = "db.password";
    private static final String PROPERTY_NAME_DATABASE_URL = "db.url";
    private static final String PROPERTY_NAME_DATABASE_USERNAME = "db.username";

    private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect";
    private static final String PROPERTY_NAME_HIBERNATE_FORMAT_SQL = "hibernate.format_sql";
    private static final String PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY = "hibernate.ejb.naming_strategy";
    private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql";
    private static final String PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN = "entitymanager.packages.to.scan";

    private static final String PROPERTY_NAME_MESSAGESOURCE_BASENAME = "message.source.basename";
    private static final String PROPERTY_NAME_MESSAGESOURCE_USE_CODE_AS_DEFAULT_MESSAGE = "message.source.use.code.as.default.message";

    @Resource
    private Environment environment;

    @Bean
    public DataSource dataSource() {
        BoneCPDataSource dataSource = new BoneCPDataSource();

        dataSource.setDriverClass(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_DRIVER));
        dataSource.setJdbcUrl(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_URL));
        dataSource.setUsername(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_USERNAME));
        dataSource.setPassword(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_PASSWORD));

        return dataSource;
    }

    @Bean
    public JpaTransactionManager transactionManager() throws ClassNotFoundException {
        JpaTransactionManager transactionManager = new JpaTransactionManager();

        transactionManager.setEntityManagerFactory(entityManagerFactoryBean().getObject());

        return transactionManager;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean() throws ClassNotFoundException {
        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();

        entityManagerFactoryBean.setDataSource(dataSource());
        entityManagerFactoryBean.setPackagesToScan(
environment.getRequiredProperty(PROPERTY_NAME_ENTITYMANAGER_PACKAGES_TO_SCAN));
        entityManagerFactoryBean.setPersistenceProviderClass(HibernatePersistence.class);

        Properties jpaProterties = new Properties();
        jpaProterties.put(PROPERTY_NAME_HIBERNATE_DIALECT, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));
        jpaProterties.put(PROPERTY_NAME_HIBERNATE_FORMAT_SQL, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_FORMAT_SQL));
        jpaProterties.put(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY));
        jpaProterties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));

        entityManagerFactoryBean.setJpaProperties(jpaProterties);

        return entityManagerFactoryBean;
    }

    @Bean
    public MessageSource messageSource() {
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();

        messageSource.setBasename(
environment.getRequiredProperty(PROPERTY_NAME_MESSAGESOURCE_BASENAME));
        messageSource.setUseCodeAsDefaultMessage(
Boolean.parseBoolean(
environment.getRequiredProperty(PROPERTY_NAME_MESSAGESOURCE_USE_CODE_AS_DEFAULT_MESSAGE)));

        return messageSource;
    }

    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();

        viewResolver.setViewClass(JstlView.class);
        viewResolver.setPrefix(VIEW_RESOLVER_PREFIX);
        viewResolver.setSuffix(VIEW_RESOLVER_SUFFIX);

        return viewResolver;
    }
}

我的Web应用程序初始化程序如下所示： 

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.*;

/**
 * Web application Java configuration class. The usage of web application
 * initializer requires Spring Framework 3.1 and Servlet 3.0.
 * @author Petri Kainulainen
 */
public class DataJPAExampleInitializer implements WebApplicationInitializer {
   
    private static final String DISPATCHER_SERVLET_NAME = "dispatcher";
    private static final String DISPATCHER_SERVLET_MAPPING = "/";
   
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
        rootContext.register(ApplicationContext.class);

        ServletRegistration.Dynamic dispatcher = servletContext.addServlet(DISPATCHER_SERVLET_NAME, new DispatcherServlet(rootContext));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping(DISPATCHER_SERVLET_MAPPING);

        servletContext.addListener(new ContextLoaderListener(rootContext));
    }
}

您可能已经注意到，我使用@PropertySource批注指定属性文件的位置，该文​​件包含使用的配置参数的值。 我的application.properties文件的内容如下： 

# The default database is H2 memory database but I have also
# added configuration needed to use either MySQL and PostgreSQL.

#Database Configuration
db.driver=org.h2.Driver
#db.driver=com.mysql.jdbc.Driver
#db.driver=org.postgresql.Driver
db.url=jdbc:h2:mem:datajpa
#db.url=jdbc:mysql://localhost:3306/datajpa
#db.url=jdbc:postgresql://localhost/datajpa
db.username=sa
db.password=

#Hibernate Configuration
hibernate.dialect=org.hibernate.dialect.H2Dialect
#hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
#hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.format_sql=true
hibernate.ejb.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy
hibernate.show_sql=true

#MessageSource
message.source.basename=i18n/messages
message.source.use.code.as.default.message=true

#EntityManager
#Declares the base package of the entity classes
entitymanager.packages.to.scan=net.petrikainulainen.spring.datajpa.model

配置Spring Data JPA

第三，您必须配置Spring Data JPA。 如果您关注的话，您可能已经注意到，我在应用程序上下文配置类中使用@ImportResource批注从XML配置文件中导入其他配置。 目前，Spring Data JPA不支持Java配置。 因此，配置它的唯一方法是使用XML配置文件。 我的pplicationContext.xml文件如下所示： 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:jpa="http://www.springframework.org/schema/data/jpa"
      xmlns:mvc="http://www.springframework.org/schema/mvc"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/data/jpa
   http://www.springframework.org/schema/data/jpa/spring-jpa-1.0.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
    <!--
       Configures the location of static resources such as css files.
       Requires Spring Framework 3.0 or higher.
   -->
    <mvc:resources mapping="/static/**" location="/static/"/>

    <!--
       Ensures that dispatcher servlet can be mapped to '/' and static resources
       are still served by the containers default servlet. Requires Spring Framework
       3.0 or higher.
   -->
    <mvc:default-servlet-handler/>

    <!--
       Configures Spring Data JPA and sets the base package of my DAOs.
   -->
    <jpa:repositories base-package="net.petrikainulainen.spring.datajpa.repository"/>
</beans>

你做完了

这就对了。 我现在已经向您展示了如何配置Spring Data JPA。 我还创建了一个示例应用程序，以演示此配置确实有效。 您可以通过从Github获取示例应用程序并使用Maven Jetty插件运行示例Web应用程序来自己测试配置（ 注意 ：请记住首先创建模型和存储库包。 因为无法向Git添加空目录临时区域 ，Github存储库也没有）。

我的Spring Data JPA教程的第二部分描述了如何使用Spring Data JPA创建一个简单的CRUD Web应用程序。 敬请关注。

参考： Spring Data JPA教程第一部分：来自Petri Kainulainen博客的JCG合作伙伴 Petri Kainulainen的配置 。

翻译自: https://www.javacodegeeks.com/2013/07/spring-data-jpa-tutorial-part-one-configuration.html

dnc8371
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring-data-jpa-extra:带有模板动态查询的spring数据jpa（例如
05-23
春天数据jpa额外使用jpa的spring数据更舒适我爱spring-data-jpa，她放开我的双手，粗鲁的方法很无聊！ 然而，尽管她为我们提供了规范解决方案，但她在动态本机查询上并不完美，而且她的返回类型必须是一个实体，但是...
SpringDataJPA教程 三种配置方式
qq_42058998的博客
05-31 1万+
SpringDataJPA教程 三种配置方式
SpringBoot JPA 中无法注入 JpaRepository 接口@ComponentScan无效
寻光人cyh的博客
10-29 4640
今天在开发过程当中出现了下面的错误： No qualifying bean of type 'xxx.xxx.xxx' available: expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.anno...
springboot Jpa多数据源（不同库）配置
热门推荐
Mr_Wanter
08-13 19万+
一、前言 springboot版本不同对多数据源配置代码有一定影响，部分方法和配置略有不同。 本文采用的springboot版本为2.3.12，数据源为mysql和postgresql 二、配置实战 2.1 基础pom <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</ar
Jpa环境配置及入门（增删改查）
wangke的博客
04-03 390
案例：客户的相关操作（增删改查） 1.分析： 1.搭建环境： 创建maven工程，导入相关坐标； 配置使用jpa的核心配置文件； 位置；需要配置到类枯井下叫做 META-INF的文件夹下 命名：persistence.xml 编写客户实体类； 配置实体类和表，类中属性和表中字段形成映射关系。 2.完成基本CRUD 2.入门代码： <properties> ...
JPA学习总结（一）--JPA的配置以及对数据库的操作
LC2586的专栏
07-25 225
[size=xx-large]什么是JPA[/size] [size=large]JPA（Java Persistence API）是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据。它的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate、Toplink、JDO等ORM框架各自为营的局面。值得注意的...
spring data jpa 教程
12-23
第一章：Spring Data JPA入门 包括：是什么、能干什么、有什么、HelloWorld等 第二章：JpaRepository基本功能 包括：代码示例JpaRepository提供的CRUD功能，还有翻页、排序等功能 第三章：JpaRepository的查询 ...
整合Spring Data JPA1
08-03
第四章节 Spring Boot 整合 Spring Data JPA（SpringBoot 高级）一、Spring Data JPA 介绍Spring Dat
Spring Data JPA 实现多表关联查询的示例代码
08-27
多表查询在spring data jpa中有两种实现方式，第一种是利用hibernate的级联查询来实现，第二种是创建一个结果集的接口来接收连表查询后的结果，这里介绍第二种方式，小编觉得挺不错的，现在分享给大家，也给大家做个...
快速学习-Spring Data JPA 之 ORM概述
12-14
第1章 ORM概述[了解] ORM（Object-Relational Mapping） 表示对象关系映射。在面向对象的软件开发中，通过ORM，就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联，操作对象就可以...
【JPA】两种不同的实现jpa的配置方法
weixin_30275415的博客
08-11 67
两种不同的实现jpa的配置方法 第一种： com.mchange.v2.c3p0.ComboPooledDataSource datasource.connection.driver_class=com.mysql.jdbc.Driver <!-- Where to find repositories --> <jpa:repositories ...
SpringBoot学习笔记九：Spring Data Jpa的使用
cxu123321的博客
10-09 2344
SpringBoot学习笔记九：Spring Data Jpa的使用 fulgens关注 72018.08.27 22:17:29字数 3,562阅读 110,836 Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范（JSR 338，这些接口所在包为javax.persistence，详细内容可参考https://github.com/javaee/jpa-spec） JP
Spring Data Jpa 详解 （配置篇）
weixin_30399871的博客
10-30 822
前言： 　　JPA全称Java Persistence API，即Java持久化API，它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据，结合其他ORM的使用，能达到简化开发流程的目的，使开发者能够专注于实现自己的业务逻辑上。 　　Spring Jpa 能够简化创建 JPA 数据访问层和跨存储的持久层功能，用户的持久层Dao接口只需要继承他自己定义好的（仓库）接口...
SpringBoot 自动配置之Spring Data JPA
yygr的博客
04-12 2379
https://www.cnblogs.com/sword-successful/p/14337507.html 前言 不知道从啥时候开始项目上就一直用MyBatis，其实我个人更喜欢JPA些，因为JPA看起来OO的思想更强烈些，所以这才最近把JPA拿出来再看一看，使用起来也很简单，除了定义Entity实体外，声明自己的业务接口继承JpaRepository接口，什么逻辑也不用写，基本的增删改查，分页，排序就都搞定了。 我在实现JpaRepository接口时就有个疑问，那么实现类是什么？如果用过
配置和使用Spring Data JPA
weixin_44308200的博客
10-29 215
目录Spring DataSpring Data 特点Spring Data接口Spring Data与JPA在Spring Boot中使用JPA导入pom.xml编写一个实体类与数据库字段进行映射编写接口继承JpaRepository使用JPA配置文件配置自定义JPA接口JPA一对一查询外键方法配置主表实体类配置附表实体类关联表方法配置主表实体类JPA一对多查询一端实体类配置多端实体类配置 Spring Data Spring Data项目的目的是为了简化构建基于Spring框架应用的数据访问技术，包括非
Spring Data JDBC示例与使用自定义 ID 插入记录
allway2的博客
10-14 2291
什么是春季数据 JDBC项目属于弹簧数据系列，并为基于 JDBC 的数据访问层提供抽象。它提供了易于使用的对象关系映射 （ORM） 框架来处理数据库。这意味着，春季数据JDBC支持使用实体对象和存储库。但是，它减少了JPA支持的引入的许多复杂性。为了使数据访问层尽可能简单，它省略了一些JPA功能，如延迟加载，实体缓存等。因此，它可以毫不费力地用于我们打算对实体执行纯 JDBC 操作的地方。与任何其他春季项目一样，可以通过添加自己的初学者依赖项，在春季启动中启用春季数据JDBC。
Spring 使用@ComponentScan扫描注解包
乐于学习、乐于分享、乐于总结
05-05 5万+
@Configuration @ComponentScan(basePackages = "org.example", nameGenerator = MyNameGenerator.class) public class AppConfig { ... } 在xml中的写法如此： <context:component-scan base-package="org.examp
spring配置packagesToScan的问题
ming1205的专栏
11-27 6739
spring配置packagesToScan的问题　　使用spirng配置pojo映射时，我们通常会使用packageToScan来简化映射配置，而且通常会使用通配符简化配置代码；比如你的model文件都在com.study.hibernate.entity包下，则配置packageToScan时不能配置成：<property name="packagesToScan"> <list>
Spring - JPA/Hibernate 整合xml配置，自动扫描实体
qq_24441947的博客
03-27 2477
0.WEB-INF结构： WEB-INF - web.xml - tickets-servlet.xml - business-config.xml 完成后：将数据库相关的配置单独列出xml文件，便于管理。在entities包内的实体（Entity）、仓库（Repository）类注解都会被自动注入。 1.新建business-config.xml文件 <b
Spring Data JPA 多数据源 实例
最新发布
06-13
好的，下面是一个简单的 Spring Data JPA 多数据源的实例： 1. 首先，需要在 pom.xml 文件中引入 Spring Data JPA 的依赖： ```xml <groupId>org.springframework.data <artifactId>spring-data-jpa <version>...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值