基于springboot2集成jpa,创建dao的案例

springboot中集成jpa需要再pom文件中添加jpa的jar包,使用springboot的话iju不用自己规定版本号了,自动管理依赖版本即可。

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

然后我们再添加hibernate和oracle的jar包,同样自动管理版本。

 <dependency>
  <groupId>org.hibernate</groupId>
  <artifactId>hibernate-core</artifactId>
 </dependency>
 <dependency>
  <groupId>com.oracle</groupId>
  <artifactId>ojdbc6</artifactId>
  <version>11.2.0.4.0</version>
 </dependency>

然后我们在配置文件中添加jpa和链接数据库的信息。

spring.datasource.driver-class-name=oracle.jdbc.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@DESKTOP-46DMVCH:1521:orcl
spring.datasource.password=****
spring.datasource.username=****
spring.mvc.date-format=yyyy-MM-dd HH:mm:ss
spring.jpa.database=oracle
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.datasource.log-abandoned=true
spring.datasource.remove-abandoned=true
spring.datasource.remove-abandoned-timeout=200

添加完成之后我们开始创建jpa使用的公共Repository,创建一个接口。这里的接口可以直接继承JpaRepository,或者可以继承别的Repository.注意要加上@NoRepositoryBean注解,告诉Spring数据:不要创建该接口实例。

当我们在下面使用dao的时候再进行创建实例

@NoRepositoryBean
public interface BaseRepository<T> extends JpaRepository<T,Long> {
}

现在我们创建好了这基础的Repository如果有自己想封装的公用方法的话就可以添加到这个接口中,进行约束。

当我们创建dao接口的时候,直接继承这个基础的Repository;继承之后这个dao再spring中默认识别为一个Repository。

public interface TbUserDao extends BaseRepository<TbUser> {
}

下面我们就可以直接再service中注入这个dao。

@Service
public class UserService {
 @Resource
 private TbUserDao userDao;
}

现在我们看一下JpaRepository源码,其中继承了PagingAndSortingRepository和QueryByExampleExecutor,也就是里面直接有了各种查询的方法,并且在这两个基础上添加了保存和删除的方法。

@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
/*
  * (non-Javadoc)
  * @see org.springframework.data.repository.CrudRepository#findAll()
  */
 List<T> findAll();
 /*
  * (non-Javadoc)
  * @see org.springframework.data.repository.PagingAndSortingRepository#findAll(org.springframework.data.domain.Sort)
  */
 List<T> findAll(Sort sort);
 /*
  * (non-Javadoc)
  * @see org.springframework.data.repository.CrudRepository#findAll(java.lang.Iterable)
  */
 List<T> findAllById(Iterable<ID> ids);
 /*
  * (non-Javadoc)
  * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable)
  */
 <S extends T> List<S> saveAll(Iterable<S> entities);
 /**
  * Flushes all pending changes to the database.
  */
 void flush();
 /**
  * Saves an entity and flushes changes instantly.
  *
  * @param entity
  * @return the saved entity
  */
 <S extends T> S saveAndFlush(S entity);
 /**
  * Deletes the given entities in a batch which means it will create a single {@link Query}. Assume that we will clear
  * the {@link javax.persistence.EntityManager} after the call.
  *
  * @param entities
  */
 void deleteInBatch(Iterable<T> entities);
 /**
  * Deletes all entities in a batch call.
  */
 void deleteAllInBatch();
 /**
  * Returns a reference to the entity with the given identifier.
  *
  * @param id must not be {@literal null}.
  * @return a reference to the entity with the given identifier.
  * @see EntityManager#getReference(Class, Object)
  * @throws javax.persistence.EntityNotFoundException if no entity exists for given {@code id}.
  */
 T getOne(ID id);
 /*
  * (non-Javadoc)
  * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example)
  */
 @Override
 <S extends T> List<S> findAll(Example<S> example);
 /*
  * (non-Javadoc)
  * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example, org.springframework.data.domain.Sort)
  */
 @Override
 <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

我们再看Jpa继承的两个接口中的代码,PagingAndSortingRepository是继承了CrudRepository的,这个CrudRepository中同样有删除保存查询等方法,是比较全的,但是如果我们直接使用这个CrudRepository的话里面的查询是没有分页的方法。

而PagingAndSortingRepository是在基础上新加了分页查询的方法。

所以我们没有直接使用CrudRepository

@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
 Iterable<T> findAll(Sort var1);
 Page<T> findAll(Pageable var1);
}

会有疑问的是我们这里的接口为什么可以直接注入。

因为当我们运行项目的时候,spring识别这个dao是一个Repository会自动为这个接口创建一个接口名+Impl的实现类,如下例子中的就是生成TbUserDaoImpl的实现类。

这个我们可以在EnableJpaRepositories注解源码中可以看到。

里面的repositoryImplementationPostfix()方法是定义repository接口生成的实现类后缀是什么,springboot默认帮我们定义成了Impl。

我们也可以在springboot启动类上面使用这个注解自己定义这个值。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(JpaRepositoriesRegistrar.class)
public @interface EnableJpaRepositories {
 /**
  * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation declarations e.g.:
  * {@code @EnableJpaRepositories("org.my.pkg")} instead of {@code @EnableJpaRepositories(basePackages="org.my.pkg")}.
  */
 String[] value() default {};
 /**
  * Base packages to scan for annotated components. {@link #value()} is an alias for (and mutually exclusive with) this
  * attribute. Use {@link #basePackageClasses()} for a type-safe alternative to String-based package names.
  */
 String[] basePackages() default {};
 /**
  * Type-safe alternative to {@link #basePackages()} for specifying the packages to scan for annotated components. The
  * package of each class specified will be scanned. Consider creating a special no-op marker class or interface in
  * each package that serves no purpose other than being referenced by this attribute.
  */
 Class<?>[] basePackageClasses() default {};
 /**
  * Specifies which types are eligible for component scanning. Further narrows the set of candidate components from
  * everything in {@link #basePackages()} to everything in the base packages that matches the given filter or filters.
  */
 Filter[] includeFilters() default {};
 /**
  * Specifies which types are not eligible for component scanning.
  */
 Filter[] excludeFilters() default {};
 /**
  * Returns the postfix to be used when looking up custom repository implementations. Defaults to {@literal Impl}. So
  * for a repository named {@code PersonRepository} the corresponding implementation class will be looked up scanning
  * for {@code PersonRepositoryImpl}.
  *
  * @return
  */
 String repositoryImplementationPostfix() default "Impl";
 /**
  * Configures the location of where to find the Spring Data named queries properties file. Will default to
  * {@code META-INF/jpa-named-queries.properties}.
  *
  * @return
  */
 String namedQueriesLocation() default "";
 /**
  * Returns the key of the {@link QueryLookupStrategy} to be used for lookup queries for query methods. Defaults to
  * {@link Key#CREATE_IF_NOT_FOUND}.
  *
  * @return
  */
 Key queryLookupStrategy() default Key.CREATE_IF_NOT_FOUND;
 /**
  * Returns the {@link FactoryBean} class to be used for each repository instance. Defaults to
  * {@link JpaRepositoryFactoryBean}.
  *
  * @return
  */
 Class<?> repositoryFactoryBeanClass() default JpaRepositoryFactoryBean.class;
 /**
  * Configure the repository base class to be used to create repository proxies for this particular configuration.
  *
  * @return
  * @since 1.9
  */
 Class<?> repositoryBaseClass() default DefaultRepositoryBaseClass.class;
 // JPA specific configuration
 /**
  * Configures the name of the {@link EntityManagerFactory} bean definition to be used to create repositories
  * discovered through this annotation. Defaults to {@code entityManagerFactory}.
  *
  * @return
  */
 String entityManagerFactoryRef() default "entityManagerFactory";
 /**
  * Configures the name of the {@link PlatformTransactionManager} bean definition to be used to create repositories
  * discovered through this annotation. Defaults to {@code transactionManager}.
  *
  * @return
  */
 String transactionManagerRef() default "transactionManager";
 /**
  * Configures whether nested repository-interfaces (e.g. defined as inner classes) should be discovered by the
  * repositories infrastructure.
  */
 boolean considerNestedRepositories() default false;
 /**
  * Configures whether to enable default transactions for Spring Data JPA repositories. Defaults to {@literal true}. If
  * disabled, repositories must be used behind a facade that's configuring transactions (e.g. using Spring's annotation
  * driven transaction facilities) or repository methods have to be used to demarcate transactions.
  *
  * @return whether to enable default transactions, defaults to {@literal true}.
  */
 boolean enableDefaultTransactions() default true;
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。

(0)

相关推荐

  • SpringBoot2.3.0配置JPA的实现示例

    JPA顾名思义就是Java Persistence API的意思,是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中. 依赖 spring-boot-starter-data-jdbc spring-boot-starter-data-jpa mysql-connector-java <dependency> <groupId>org.springframework.boot</groupId> <artifactId&g

  • SpringBoot JPA使用配置过程详解

    JPA是什么? JPA(Java Persistence API)是Sun官方提出的Java持久化规范. 为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据. 它的出现是为了简化现有的持久化开发工作和整合ORM技术. 结束各个ORM框架各自为营的局面. JPA 其实是一种规范,它的实现中比较出名的是 Hibernate 框架: 1.pom 引入依赖: <dependency> <groupId>org.springframework.boot</gr

  • 解决springboot无法注入JpaRepository的问题

    使用内置服务器启动springboot项目时,会从@SpringBootApplication修饰类所在的包开始,加载当前包和所有子包下的类,将由@Component @Repository @Service @Controller修饰的类交由spring进行管理. package com.facade; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure

  • springboot整合Mybatis、JPA、Redis的示例代码

    引言 在springboot 项目中,我们是用ORM 框架来操作数据库变的非常方便.下面我们分别整合mysql ,spring data jpa 以及redis .让我们感受下快车道. 我们首先创建一个springboot 项目,创建好之后,我们来一步步的实践. 使用mybatis 引入依赖: <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-

  • SpringBoot整合spring-data-jpa的方法

    jpa是JavaEE定义的一种规范,常用的实现一般是Hibernate,而spring-data-jpa则是对jpa的又一层封装,提供了更多便捷的方法. 这里不会深入讲解spring-data-jpa的使用,只是讲解怎么快速的整合使用,目的是帮助那些想学,但是在整合上老是翻车的同学 导入依赖 <dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> &

  • SpringBoot整合JPA数据源方法及配置解析

    一.创建项目并导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>dr

  • 基于springboot2集成jpa,创建dao的案例

    springboot中集成jpa需要再pom文件中添加jpa的jar包,使用springboot的话iju不用自己规定版本号了,自动管理依赖版本即可. <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> 然后我们再添加hibernate和o

  • 基于spring boot 1.5.4 集成 jpa+hibernate+jdbcTemplate(详解)

    1.pom添加依赖 <!-- spring data jpa,会注入tomcat jdbc pool/hibernate等 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <

  • SpringBoot2 实现JPA分页和排序分页的案例

    分页 application.yml spring: datasource: url: jdbc:mysql://127.0.0.1/jpa?useUnicode=true&characterEncoding=utf-8&useSSL=false username: root password: 123456 driver-class-name: com.mysql.jdbc.Driver jpa: hibernate: # 更新或者创建数据表结构 ddl-auto: update # 控

  • Spring Boot2.x集成JPA快速开发的示例代码

     什么是JPA 一种规范,并非ORM框架,也就是ORM上统一的规范 spring-boot-starter-data-jpa 是Spring Boot的项目,包含了spring-data-jpa和一些其他依赖用于Spring Boot项目 spring-data-jpa 是Spring Data的项目,就是本体,用于任何项目 解决 为了执行简单查询分页,编写太多重复代码 基于JPA的数据访问层的增强支持 用了之后可以做什么,为什么要用?如下代码解释 实体类 package com.example

  • SpringBoot集成JPA的示例代码

    本文介绍了SpringBoot集成JPA的示例代码,分享给大家,具体如下: 1.创建新的maven项目 2. 添加必须的依赖 <!--springboot的必须依赖--> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.9.RELEASE

  • SpringBoot集成JPA持久层框架,简化数据库操作

    目录 与SpringBoot2.0整合 1.核心依赖 2.配置文件 3.实体类对象 4.JPA框架的用法 5.封装一个服务层逻辑 测试代码块 源代码地址 与SpringBoot2.0整合 1.核心依赖 <!-- JPA框架 --> <dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-starter-data-jpa<

  • 基于NodeJS+MongoDB+AngularJS+Bootstrap开发书店案例分析

    这章的目的是为了把前面所学习的内容整合一下,这个示例完成一个简单图书管理模块,因为中间需要使用到Bootstrap这里先介绍Bootstrap. 示例名称:天狗书店 功能:完成前后端分离的图书管理功能,总结前端学习过的内容. 技术:NodeJS.Express.Monk.MongoDB.AngularJS.BootStrap.跨域 效果: 一.Bootstrap Bootstrap是一个UI框架,它支持响应式布局,在PC端与移动端都表现不错. Bootstrap是Twitter推出的一款简洁.直

  • Java基于装饰者模式实现的染色馒头案例详解

    本文实例讲述了Java基于装饰者模式实现的染色馒头案例.分享给大家供大家参考,具体如下: 一.模式定义 装饰者模式,是在不改变原类文件和使用继承的情况下,动态扩展一个对象功能,它是通过创建一个包装对象,也就是装饰来包装真实的对象. 装饰对象和真实对象有相同接口,这样客户端对象就可以和真实对象相同方式和装饰对象交互. 装饰对象包含一个真实对象的引用. 二.模式举例 1. 模式分析 我们借用黑心商贩制做染色馒头案例说明这一模式. 2. 装饰者模式静态类图 3. 代码示例 3.1 创建馒头接口--IB

  • 基于Springboot2.3访问本地路径下静态资源的方法(解决报错:Not allowed to load local resource)

    最近在做的一个项目中有一个比较奇葩的需求: 要在springboot中,上传本地的图片进行展示 我的第一反应是,直接在数据库字段加一个存储本地路径的字段,然后用thymeleaf的th:src渲染到前端就好了嘛! 理想很丰满,但现实却很骨感~ 前端报了这样的错误Not allowed to load local resource 于是我想到了可以使用IO将图片先上传到static/images目录下,这样就不会出现禁止访问本地路径的问题了 但是这样实现,问题又来了:上传后的图片必须重启sprin

  • 基于SpringBoot2.0默认使用Redis连接池的配置操作

    SpringBoot2.0默认采用Lettuce客户端来连接Redis服务端的 默认是不使用连接池的,只有配置 redis.lettuce.pool下的属性的时候才可以使用到redis连接池 redis: cluster: nodes: ${redis.host.cluster} password: ${redis.password} lettuce: shutdown-timeout: 100 # 关闭超时时间 pool: max-active: 8 # 连接池最大连接数(使用负值表示没有限制

随机推荐