SpringDataJpa+Hibernate+Spring搭建环境

最新推荐文章于 2024-08-12 22:02:10 发布
最新推荐文章于 2024-08-12 22:02:10 发布
阅读量305 收藏
点赞数
文章标签： SpringDataJpa Hibernate Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anget/article/details/86232010
版权

先贴上pom.xml

<?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>Spring+SpringData+mybatis+Maven</groupId>
    <artifactId>30</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--德鲁伊以及Mysql-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.29</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
        <!--切面以及事务相关Jar-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>com.springsource.org.aspectj.weaver</artifactId>
            <version>1.6.8.RELEASE</version>
        </dependency>
        <!--SpringDataJpa+Hibernate-->
        <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>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.7.Final</version>
        </dependency>
        <!--Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.3.RELEASE</version>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>     <!-- 桥接：告诉Slf4j使用Log4j2 -->
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId> <!-- 桥接：log4j1使用Log4j2 也支持其他实现到log4j的桥接，引入不同的jar包即可-->
            <artifactId>log4j-over-slf4j</artifactId>
            <version>1.7.12</version>
        </dependency>
        <!-- 使用异步写日志功能 必须引入此包-->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <!-- maven项目中src源代码下的xml等资源文件编译进classes文件夹，
              注意：如果没有这个，它会自动搜索resources下是否有mapper.xml文件，
              如果没有就会报org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.pet.mapper.PetMapper.selectByPrimaryKey-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <!--将resources目录下的配置文件编译进classes文件  -->
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Spring.XML

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
         http://www.springframework.org/schema/tx/spring-tx.xsd
         http://www.springframework.org/schema/data/jpa
         http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    <context:property-placeholder location="classpath*:config.properties"
                                  ignore-unresolvable="true"/>
    <context:component-scan base-package="service"/>
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}"/>
        <property name="username" value="${jdbc_username}"/>
        <property name="password" value="${jdbc_password}"/>
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="0"/>
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20"/>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0"/>
        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000"/>
        <property name="validationQuery" value="SELECT 1"/>
        <property name="testOnBorrow" value="false"/>
        <property name="testOnReturn" value="false"/>
        <property name="testWhileIdle" value="true"/>
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000"/>
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="25200000"/>
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true"/>
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800"/>
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true"/>
        <!-- 监控数据库 -->
        <property name="filters" value="mergeStat"/>
    </bean>
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 扫描实体类 -->
        <property name="packagesToScan" value="pojo"></property>
        <!--JPA供应商适配 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
        </property>
        <!-- 配置hibernate的其他属性 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</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>
    <!--Spring-Data-JPA事务-->
    <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <tx:advice transaction-manager="txManager" id="tx_advice">
        <tx:attributes>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="load*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut expression="execution(* dao.*.*(..))" id="txPointcut"/>
        <aop:advisor advice-ref="tx_advice" pointcut-ref="txPointcut"/>
    </aop:config>
    <jpa:repositories base-package="dao"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="txManager"/>
</beans>

实体类

package pojo;

import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import java.util.Objects;

@Entity
public class Student {
    private int id;
    private String name;
    private Integer age;
    private String password;

    @Id
    @Column(name = "id", nullable = false)
    public int getId() {
        return id;
    }

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

    @Basic
    @Column(name = "name", nullable = true, length = 20)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Basic
    @Column(name = "age", nullable = true)
    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Basic
    @Column(name = "password", nullable = true, length = 20)
    public String getPassword() {
        return password;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                Objects.equals(name, student.name) &&
                Objects.equals(age, student.age) &&
                Objects.equals(password, student.password);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, password);
    }
}

DAO接口要使用注解或者继承
domainClass是你的实体类。就是指你这个接口会用到那个实体类你就使用那个
然后Idclass就是你的id类型。如果你数据库的id是int那就直接Integer

package dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.data.repository.RepositoryDefinition;
import pojo.Student;

import java.util.List;
@RepositoryDefinition(domainClass =Student.class,idClass = Integer.class)
public interface Studao {
    List<Student> findByNameIs(String name);
    Student findByIdIs(int id);
}

测试类

import dao.Studao;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import pojo.Student;

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath*:applicationContext.xml")
public class Test {
    @Autowired
    private Studao studao;
    @org.junit.Test
    public void testDataSouce() {
        Student aa = studao.findByIdIs(1);
        System.out.println(aa);
    }
}

测试结果

Hibernate: 
    
    create table Student (
       id integer not null,
        age integer,
        name varchar(20),
        password varchar(20),
        primary key (id)
    ) engine=MyISAM
Hibernate: 
    select
        student0_.id as id1_0_,
        student0_.age as age2_0_,
        student0_.name as name3_0_,
        student0_.password as password4_0_ 
    from
        Student student0_ 
    where
        student0_.id=?
pojo.Student@3c1d56

Process finished with exit code 0
鬼哦
关注
JPA和Hibernate到底是什么关系？？？
diaoyinyuan2801的博客
08-17 1363
（文章借用了其他几篇博客中的内容，因为是初学者，许多概念性的关系自己不能完全理解，就将大神的搬了过来，如有不当，可留言，本人自会妥善处理，谢谢） 在学习框架的过程中，发现学的东西很多，但是感觉他们之间的联系区别都不是很了解，知道JPA可以去实现持久化数据到数据库当中，Hibernate也有这样的功能，总以为他们之间是一种平级的关系，拥有同样的作用，是一种可以相互替代的关系，就像你吃...
从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate
09-02
以上就是从一个基础的Java工程逐步构建到集成Spring、SpringMVC、SpringDataJPA+Hibernate的过程。这个过程展示了如何配置Maven工程、转换为Web工程、集成Spring框架、SpringMVC和数据访问层。理解这些步骤有助于你...
spring data jpa hibernate jpa 三者之间的关系
weixin_34239592的博客
01-22 1302
JPA规范与ORM框架之间的关系是怎样的呢？ JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现，JBoss应用服务器底层就以Hibernate作为JPA的实现。 既然JPA作为一种规范——也就说JPA规范中提供的只是一些接口，显然接...
Spring Boot 和 Hibernate 的简单整合
最新发布
D_J_Dragon的博客
08-12 1084
打开浏览器访问http://localhost:8080/UserController/test，可以看到页面上有一行数据，刚好和UserController类中的代码功能一致，同时控制台也打印出了insert语句，说明调用成功。Spring Data JPA是由Spring公司开发的JPA应用框架，用于整合市面上已有的ORM框架，它默认使用Hibernate，可见Hibernate仍然是一个强大且稳定的持久层解决方案。需要配置好自己的数据库连接，用户名，密码。User类就是实体类，和数据库中的表对应。
使用Spring Data JPA和Hibernate框架
Mr_Dracy的博客
02-28 284
创建实体类 • @Entity：实体类的标识 • @Table：映射的表名 • @Id：数据ID的标识 • @Column：字段名的映射 ID自动生成策略 • @GeneratedValue中的strategy属性用来指定ID生成策略，JPA提供了四 种： • GenerationType.TABLE：使用一个特定的数据库表格来保存主键 • GenerationType.SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持 序列。 • GenerationType.IDENTITY：主键由数据
SpringDataJPA+Hibernate框架源码剖析（一）框架介绍
yangxiaofei_java的博客
02-21 1212
SpringDataJPA+Hibernate框架源码剖析系列文章： SpringDataJPA+Hibernate框架源码剖析（一）框架介绍 SpringDataJPA+Hibernate框架源码剖析（二）框架整合 之 EntityManagerFactory的构建 SpringDataJPA+Hibernate框架源码剖析（三）框架整合 之 Repository接口实现的生成 SpringDataJPA+Hibernate框架源码剖析（四）框架整合 之 事务管理器的构建 SpringDataJPA+H
JPA-Hibernate
Wqr_18390921824的博客
12-01 839
一. JPA与hibernate的关系 JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。 JPA和Hibernate的关系就像JDBC和数据库JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要..
Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA
06-10
在现代Java Web开发中，"Maven整合Spring+SpringMVC+Hibernate+SpringDataJPA"是一个常见的架构组合，被广泛应用于构建企业级应用程序。这个组合通常被称为"SSM"，其中"M"代表Maven，"S"代表Spring，包括Spring核心...
Spring+SpringMVC+SpringDataJPA+Hibernate
05-15
在搭建SpringMVC+SpringDataJPA+Hibernate项目时，首先需要配置Spring的IoC容器，然后引入Spring MVC的依赖，以处理HTTP请求和响应。接着，配置Spring Data JPA和Hibernate，包括数据源、实体管理工厂、事务管理器等...
2017 spring data jpa+spring4.2+springmvc+hibernate4.3 maven环境intellij idea增删改查实例
07-22
综上所述，这个实例提供了一个完整的Java Web开发环境，展示了如何使用Spring Data JPA、Spring 4.2、Spring MVC和Hibernate 4.3进行数据操作，以及如何利用Maven进行项目管理，同时借助IntelliJ IDEA提升开发效率。...
SpringBoot+Spring data JPA+FreeMarker+shiro+log4jdbc
07-14
Spring Data JPA是Spring Framework的一个模块，它简化了数据访问层的开发。它提供了对ORM（对象关系映射）供应商如Hibernate、EclipseLink等的一致性支持。通过Spring Data JPA，开发者可以利用泛型接口和方法命名...
jpa+HIBERNATE的一个简单例子
03-29
jpa和hibernate的一个简单例子
spring data jpa 中文文档
07-25
spring data jpa 中文文档，spring data中文文档，spring data jpa 中文文档
JPA & Hibernate
Lazyafei's Blog
02-07 296
在2006年初始发布JPA 1.0之前，有许多供应商在对象关系映射（ORM）工具领域进行竞争，他们都拥有非常相似的API，可以实现许多相同的目标。但~是，这些项目都没有兼容和可互换的代码。JPA的目标是标准化Java应用程序如何执行ORM。在JPA 1.0中，所有竞争实现都是统一的，因为它们现在都实现了一个通用的标准API。 然而，由于Hibernate的普及，许多人在真正意味着JPA时继续使用Hibernate一词。Hibernate成为JPA的同名词，正如Kleenex是浴室纸巾的同名词一样。即使在今天
JPA与hibernate
weixin_42494845的博客
08-23 549
hibernate概述 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 JPA概述 JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。 JPA通过JDK 5.0注解描述对象－关系表
谈hibernate，jpa与spring data jpa三者之间的关系
热门推荐
qq_41300350的博客
05-01 1万+
前提 其实很多框架都是对另一个框架的封装，我们在学习类似的框架的时候，难免会进入误区，所以我们就应该对其进行总结归纳，对比。 本文就是对hibernate，jpa，spring data jpa三者之间进行文字对比，以及对其三者分别进行CRUD操作。 文字说明 Hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建...
spring data jpa + hibernate
weixin_30410119的博客
08-20 66
在spring中利用data jpa和hibernate，可以节省很多底层model的处理代码 但使用过spring的人大概最头疼的往往不是写代码，而是臭长的配置文件 比如现在遇到的entitymanager报错 org.springframework.beans.factory.BeanCreationException: Error creating bean with name '...
SpringData【Spring整合Hibernate】
波波烤鸭的博客
05-18 4654
  后面几篇文章会详细的介绍SpringData相关的内容，本文先介绍下Spring整合Hibernate的相关内容，如果对于hibernate还不太熟悉可以参考如下的资料补充学习: 链接：https://pan.baidu.com/s/1rKv-XY8xLxqvAOt3Oe3myQ 提取码：q0zk Spring整合Hibernate 1.创建maven项目   通过IDEA或者Eclipse创...
Spring Data初步--整合Hibernate
欢迎来到我的博客，一起学习Java！
11-11 562
Spring Data课程中的技术介绍 Hibernate： Hibernate 是一个开放源代码的对象关系映射框架，它对 JDBC 进行了非常轻量级的对象封装，它将 pojo 与数据库表建立映射关系，是一个全自动的 ORM（Object - Relationship - Mapping）框架，Hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以随心所欲的使用对...
构建基础Java工程：SpringMVC+SpringDataJPA+Hibernate详解
本文主要介绍了如何从头开始构建一个基于Java的Web应用程序，特别关注于集成Spring、SpringMVC、SpringData JPA和Hibernate这四个核心组件。首先，文章强调了使用Maven作为项目管理工具的优势，即使对于非Maven项目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值