Spring+Hibernate+SpringJPA

置顶 于 2019-09-05 16:32:47 发布
阅读量132 收藏
点赞数
分类专栏： 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43343423/article/details/100560578
版权

dao层几种配法

1.优先使用内置接口方法
2.按方法命名规范定义接口
3.手动定制sql或hql方式
4.手动提供接口实现类

第一种UserRepository

package dao;

import model.User;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
/**
 * JPA接口
 */
//@RepositoryDefinition(domainClass =User.class ,idClass = Integer.class)
public interface UserRepository extends Repository<User, Integer> {

    //1.只声明接口方式(使用方法命名规范)
    User getUserById(int id);


    //2.声明hql方式
    @Query(value = "from User where username=?1 and password=?2")
    User selectByHql(String username,String password);

    //3.声明Sql方式
    @Query(value = "select * from User where username=? and password=?",nativeQuery = true)
    User selectBySql(String username,String password);

    //4.可以手动定制增删改操作
    @Query(value = "insert into user(username,password) values(?,?)",nativeQuery = true)
    @Modifying
    void insert(String username,String password);

}

第二种UserRepository2

package dao;

import model.User;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface UserRepository2 extends JpaRepository<User,Integer> {

    //只支持查询和删除(后面可以拼接丰富的条件)
    List<User> findUserByIdBetween(int begining, int ending, Pageable pageable);


}

第三种多继承扩容型（自定义实现类）
BaseRepository（自定义实现接口）

package dao;

/**
 * 自定义接口,并提代其实现
 */
public interface BaseRepository {

    Long sum();
}

BaseRepositoryImpl(最好以Impl结尾，因为这是框架约定)
如果要重新定制规则
在这里插入图片描述
就要配置接口实现后缀名自定义

package dao;

import org.springframework.beans.factory.annotation.Autowired;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

public class BaseRepositoryImpl implements BaseRepository {

    //@Autowired
    @PersistenceContext
    private EntityManager entityManager;

    /**
     * 查询总记录数
     * @return
     */
    @Override
    public Long sum() {

        String hql = "select count(*) from User";
        Query query = entityManager.createQuery(hql);
        Long count = (Long)query.getSingleResult();

        return count;
    }
}

SubRepository

package dao;

import model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface SubRepository extends BaseRepository,JpaRepository<User,Integer> {
}

pom配置

<?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>com.sy</groupId>
    <artifactId>0415_springdatajpa_day01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>



    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--Spring相关包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>

        <!--Spring JPA-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        <!--JPA:Java Pesistence API-->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
        </dependency>
        <!--JPA实现-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.0.Final</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>
        <!--数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.2</version>
        </dependency>
    </dependencies>
</project>

spring.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:jpa="http://www.springframework.org/schema/data/jpa"
       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.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">


    <!--1.加载properties文件 -->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--2.创建dataSource实例-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db_driver}"></property>
        <property name="url" value="${db_url}"></property>
        <property name="username" value="${db_user}"></property>
        <property name="password" value="${db_password}"></property>
    </bean>



    <!--3.扫描Dao层接口,生成代理对像-->
    <jpa:repositories base-package="dao"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="txManager"
                      repository-impl-postfix="Impl"></jpa:repositories>


    <!--4.entityManagerFactory相当于hibernate中SessionFactory
        EntityManager相当hibernate的Session-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!--指定hibernate实现-->
        <property name="jpaVendorAdapter">
            <bean  class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="false"></property>
            </bean>
        </property>
        <!--扫描hibernate注解-->
        <property name="packagesToScan" value="model"></property>

        <property name="jpaProperties">
            <props>
                <!--把数据库表的列映射成对像属性,如USER_ID映射成属性userId-->
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.hbm2ddl.auto">validate</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</prop>
            </props>
        </property>
    </bean>

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

    <!--6.事务驱动-->
    <tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven>

    <!--7.开启DI扫描-->
    <context:component-scan base-package="service"></context:component-scan>
</beans>

db.properties

db_driver=com.mysql.jdbc.Driver
db_url=jdbc:mysql:///javaee
db_user=root
db_password=tiger

model包

package model;

import javax.persistence.*;

@Entity
@Table(name = "USER")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String username;
    private String password;

    public Integer getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

方法一Service

package service;


import dao.UserRepository;
import model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional(readOnly = true)
public class UserService {

    @Autowired
    private UserRepository repository;

    public User findById(int id){
        return repository.getUserById(id);
    }

    public User findByHql(String username,String password){
        return repository.selectByHql(username, password);
    }

    public User findBySql(String username,String password){
        return repository.selectBySql(username, password);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void save(User user){
        repository.insert(user.getUsername(),user.getPassword());
    }
}

方法二对应Service

package service;

import com.sun.prism.shader.DrawSemiRoundRect_Color_AlphaTest_Loader;
import dao.UserRepository2;
import model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

@Service
@Transactional(readOnly = true)
public class UserService2 {

    @Autowired
    private UserRepository2 repository2;

    @Transactional(propagation = Propagation.REQUIRED)
    public void save(User user){
        repository2.save(user);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void remove(User user){
        repository2.delete(user);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public void modify(User user){
        repository2.save(user);
    }

    public User findById(int id){

        Optional<User> optionalUser = repository2.findById(id);

        User user = optionalUser.get();

        return user;
    }

    public List<User> findAll(){

        return repository2.findAll();
    }

    public List<User> findWithSort(Sort sort){


        return repository2.findAll(sort);

    }

    public Page<User> findWithPage(Pageable pageable){

        return repository2.findAll(pageable);

    }

    public List<User> findUserByIdBetweenAnd(int begin,int end,Pageable pageable){

        return repository2.findUserByIdBetween(begin, end, pageable);
    }
 }

方法3对应Service

package service;

import com.sun.xml.internal.ws.client.sei.ResponseBuilder;
import dao.SubRepository;
import dao.UserRepository;
import dao.UserRepository2;
import model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Optional;

@Service
@Transactional(readOnly = true)
public class UserService3 {

    @Autowired
    private SubRepository repository;

    /**
     * 使用JPA接口中的方法
     * @param id
     * @return
     */
    public User findById(int id){;
        Optional<User> optionalUser = repository.findById(id);
        return optionalUser.get();
    }

    /**
     * 使用自定义父接口中方法
     * @return
     */
    public Long sum(){
        return repository.sum();
    }
 }
砂锅大的拳头
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring + JPA + Hibernate配置
03-17
库文件 博文链接：https://log-cd.iteye.com/blog/562054
Spring整合Hibernate JPA
weixin_50216991的博客
04-24 1369
一个小笔记
spring + jpa + hibernate
qq_26182553的博客
07-13 283
1. 添加依赖Jar文件。除了必要的spring和Hibernate依赖外，下面的jar必不可少， 否则会抛出异常“No Persistence provider for EntityManager named *” org.hibernate hibernate-entitymanager 4.2.8.Final 2. spring-jpa-hibernat
jpa+spring+hibernate
cxfking的专栏
03-04 499
一 前言        最近在做个项目,JPA使用了hibernate3.6.后来觉得JPA单独使用不是很给力,于是就想到了和spring集成.刚开始,我是用spring2.5.6和hibernate3.6集成的,屡次不成功.后来研究发现,hibernate3.6的JPA是2.0的.狂晕.下面是spring3.0.5(支持JPA2.0)和hibernate3.6集成,其中源代码在附件里， 只有
11.Spring + Hibernate + JPA
Save you from anything
08-28 2168
1.
Spring + hibernate + JPA 配置
weixin_33730836的博客
10-02 106
最近对hibernate的JPA实现比较感兴趣，在此记录下配置方法，备查。先上maven依赖包配置，这里使用的是spring3.1.2和hibernate3.6.0<dependencies> <dependency> <groupId>org.hibernate</groupI...
spring+springMVC+jpa+hibernate框架整合
01-07
spring4.0.1 springMVC jpa2.0 hibernate4.3.7 框架整合
springMVC+spring+hibernate+jquery分页完整项目，完整代码
01-04
springMVC+spring+hibernate+jquery分页完整项目，完整代码
spring3+springmvc+jpa+hibernate
03-21
实现了spring3+springmvc+jpa2.0+hibernate之间的集成，框架搭建。项目可以直接在tomcat中运行
hibernate(jpa)+spring
qq_33854869的博客
07-13 500
项目中用到了hibernate,抽个时间记录下(前面有个简陋的介绍spring+redis+hibernate,此篇对hibernate有个更为详细的使用). Hibernate是一种ORM(Object Relational Mapping)映射工具，能够建立面向对象的域模型和关系数据模型之间的映射 Object Mapping（Hibernate） Relational 面向对象领域
springmvc+maven+hibernate(JPA)实现的一个简易博客系统
07-03
基于springmvc+maven+hibernate做的一个简易博客系统，方便对于springmvc的掌握和入门，按照过程一个个自己实践，相信会有一个不错的入门效果（仅作为入门，掌握springmvc和hibernate（JPA）所用，比如对于JPARepository的扩展和使用等） attention：正式开始前，请检查自己的环境（javaJDK，maven均正常，安装和检查过程请摆渡）
Spring+SpringMVC+SpringDataJPA+Hibernate
05-15
手把手教你从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate。 http://blog.csdn.net/anxpp中有详细搭建教程
springmvc+jpa(hibernate实现)+spring整合实例
04-29
工作用了springmvc+jpa+spring这么长时间，这段时间正好有点时间就想整合一下，但在整合过程中遇到了各种问题，上网查了很多资料但讲的都很模糊或者是没有注释，在我一步一步的试验中终于整合成功了，做为我自已以后复习用的资料我注释写的很全，其中项目里面的配置文件或是代码每行都有注释，网上这种整合实例很少，就奉献出来大家一起学习吧，在整合过程中遇到一个很奇怪的问题，就是spring的事务我配置成@Transactional(readOnly = true)只读事务，但是还可以对数据库进行操作，大家如果知道原因的就一起交流下吧
spring+hibernate JPA
qiuyabing的专栏
05-07 111
关于spring+hibernate JPA的一个例子       通过spring配置来实现对数据库的访问和对事务的管理 简单的对一张表（table）的操作 实体类： User.java package domain; import javax.persistence.Column;import javax.persistence.Entity;import javax.pers...
Spring整合Hibernate实现JPA持久化
云水之路的专栏
11-21 7508
Spring整合Hibernate实现JPA持久化 本篇文章主要介绍Spring如何集成JPA的功能，并实现基本的CURD操作。JPA，全称为Java Persistence API，诞生与EJB2实体Bean之上，是一种新的Java持久化标准，也是基于POJO的持久化机制，它的设计灵感来源于Hibernate和Java数据对象（JDO）。  Maven管理软包依赖  配置实体管理器工厂  用JPA方式实现CURD
springBoot+Hibernate(Jpa)多数据源配置与使用
热门推荐
慕云白博客
02-10 5万+
在学习的过程中，大多时候项目与数据库都在本机上，使用hibernate或者mybatits加上简单的配置就能够打通程序到数据库路径，让程序能够访问到数据库。然而在一些情况下，我们不仅需要访问本机的数据库，还需要访问到另外一个数据库中的资源。本文书写的目的便在于解决访问多资源库的问题，更多的是为了交流与学习。学习，源码是很重要的。文末给出了我的Github中的源码链接，感兴趣的可以下载阅览。 ...
SPRING+JPA+Hibernate配置方法
weixin_33961829的博客
06-04 163
1.applicationContext.xml 1 <?xml version="1.0" encoding="UTF-8"?> 2 <beans xmlns="http://www.springframework.org/schema/beans" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-ins...
叫你们如何简单快速搭建SpringBoot+hibernate+jpa
CSDN新星计划JAVA赛道TOP5、CSDN内容合伙人、JAVA领域优质创作者、资深JAVA开发深耕JAVA领域。
05-31 1238
不用写一句sql即可完成增删改查等简单操作创建maven项目，导入相关的依赖jar写入状态信息写入service基础baseService根据http请求返回json数据项目目录这是一个非常好用的一个架构，后面可以连接安卓，提供数据的访问和保存有兴趣的加我微信：L1348503271关注本人微博：李日兴LRX...
Springmvc+Hibernate+JPA Maven环境搭
chrisjingu的专栏
07-11 3764
近期，公司一直在用Springmvc+Hibernate+Jpa开发项目，这里总结一下，近两个月的研究成果。一来，做个记录，方便自己后期查阅。二来，希望可以帮到，正在用同样框架开发，却还在挠头抓耳疯狂查阅资料的IT同行们。废话少说下面开始介绍：所需要依赖包如下：spring-beans-4.1.2.RELEASE.jar spring-context-4.1.2.RELEASE.jar spri
spring boot + hibernate
最新发布
04-30
通常情况下，Spring Boot的自动化配置机制可以帮助我们自动配置Hibernate，并且提供了很多与Hibernate相关的组件和插件，例如Spring Data JPA，可以帮助我们更加方便地使用Hibernate进行数据库访问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值