devbox
爱喝兽奶帝天荒
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot集成Hibernate_springboot hibernate

作者：爱喝兽奶帝天荒 | 2024-07-12 18:09:31

赞

踩

springboot hibernate

Hibernate是什么？

Hibernate与MyBatis都是流行的持久层开发框架，只不过Hibernate是全自动ORM框架，不需要关心sql编写。

Hibernate 是一个高性能的对象/关系映射（ORM）持久化存储和查询的服务，不仅负责从Java类到数据库表的映射 （还包括从Java数据类型到SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短了手动处理SQL和JDBC上的开发时间。 同时，Hibernate还实现了JPA规范，在SpringBoot中，JPA的默认实现就是使用的Hibernate。

JPA和Hibernate？

JPA

JPA(Java Persistence API)是Sun官方提出的Java持久化规范，它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据。

可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。

JPA仅仅是一种规范，也就是说JPA仅仅定义了一些接口，而接口是需要实现才能工作的。所以底层需要某种实现，而Hibernate就是实现了JPA接口的ORM框架。

Hibernate

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的ORM框架。 Hibernate可以自动生成SQL语句、自动执行，从而使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

实际上，JPA规范制定过程中就是借鉴了Hibernate等这些开源的持久框架，也就是说Hibernate的出现比JPA还要早些。

在Hibernate中使用的注解就是JPA注解，Hibernate实现了JPA规范。

Spring Data JPA

spirng data jpa是spring提供的一套简化JPA开发的框架，按照约定好的【方法命名规则】写dao层接口，就可以在不写接口实现的情况下，实现对数据库的访问和操作。同时提供了很多除了CRUD之外的功能，如分页、排序、复杂查询等等。

Spring Data JPA 可以理解为 JPA 规范的再次封装抽象，底层还是使用了 Hibernate 的 JPA 技术实现。

SpringData

Spring Data 是持久层通用解决方案，支持 关系型数据库 Oracle、MySQL、非关系型数据库NoSQL、Map-Reduce 框架、云基础数据服务 、搜索服务。

Spring Data是一个开源框架而Spring Data JPA是这个框架的模块。

一、新建SpringBoot项目

在pom.xml中引入maven依赖

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  4.         </dependency>
  5.  
  6.         <dependency>
  7.             <groupId>mysql</groupId>
  8.             <artifactId>mysql-connector-java</artifactId>
  9.             <version>8.0.17</version>
  10.             <scope>runtime</scope>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>com.alibaba</groupId>
  14.             <artifactId>druid</artifactId>
  15.             <version>1.1.2</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.projectlombok</groupId>
  19.             <artifactId>lombok</artifactId>
  20.             <version>1.18.10</version>
  21.         </dependency>

创建数据库

  1. create table books
  2. (
  3. 	book_id int(5) primary key	auto_increment,
  4. 	title varchar(200),
  5. 	category varchar(100)
  6. )
  7. INSERT INTO `books` (`book_id`, `title`, `category`) VALUES
  8. 	(1, '123', 'qwe'),
  9. 	(2, '456', 'asd'),
  10. 	(3, '789', 'zxc');

配置文件application.yml

  1. spring:
  2.   jpa:
  3.     properties:
  4.       hibernate:
  5.         dialect: org.hibernate.dialect.MySQLDialect
  6.         new_generator_mappings: false
  7.         format_sql: true
  8.   datasource:
  9.     url: jdbc:mysql://localhost:3306/ss?serverTimezone=UTC&useSSL=false&autoReconnect=true&tinyInt1isBit=false&useUnicode=true&characterEncoding=utf8
  10.     username: root
  11.     password: 123qwe

创建如图以下包

在config下编写数据源配置

  1. @Configuration
  2. @EnableTransactionManagement(order = 2)
  3. public class DataSourceConfig {
  4.     @Resource
  5.     private DruidProperties druidProperties;
  6.  
  7.     /**
  8.      * 单数据源连接池配置
  9.      */
  10.     @Bean
  11.     public DruidDataSource singleDatasource() {
  12.         DruidDataSource dataSource = new DruidDataSource();
  13.         druidProperties.config(dataSource);
  14.         return dataSource;
  15.     }
  16. }
  1. @Component
  2. @ConfigurationProperties(prefix = "spring.datasource")
  3. public class DruidProperties {
  4.     private String url;
  5.  
  6.     private String username;
  7.  
  8.     private String password;
  9.  
  10.     private String driverClassName = "com.mysql.cj.jdbc.Driver";
  11.  
  12.     private Integer initialSize = 10;
  13.  
  14.     private Integer minIdle = 3;
  15.  
  16.     private Integer maxActive = 60;
  17.  
  18.     private Integer maxWait = 60000;
  19.  
  20.     private Boolean removeAbandoned = true;
  21.  
  22.     private Integer removeAbandonedTimeout = 180;
  23.  
  24.     private Integer timeBetweenEvictionRunsMillis = 60000;
  25.  
  26.     private Integer minEvictableIdleTimeMillis = 300000;
  27.  
  28.     private String validationQuery = "SELECT 'x'";
  29.  
  30.     private Boolean testWhileIdle = true;
  31.  
  32.     private Boolean testOnBorrow = false;
  33.  
  34.     private Boolean testOnReturn = false;
  35.  
  36.     private Boolean poolPreparedStatements = true;
  37.  
  38.     private Integer maxPoolPreparedStatementPerConnectionSize = 50;
  39.  
  40.     private String filters = "stat";
  41.  
  42.     public void config(DruidDataSource dataSource) {
  43.         dataSource.setDbType(JdbcConstants.MYSQL);
  44.         dataSource.setUrl(url);
  45.         dataSource.setUsername(username);
  46.         dataSource.setPassword(password);
  47.         dataSource.setDriverClassName(driverClassName);
  48.         // 定义初始连接数
  49.         dataSource.setInitialSize(initialSize);
  50.         // 最小空闲
  51.         dataSource.setMinIdle(minIdle);
  52.         // 定义最大连接数
  53.         dataSource.setMaxActive(maxActive);
  54.         // 获取连接等待超时的时间
  55.         dataSource.setMaxWait(maxWait);
  56.         // 超过时间限制是否回收
  57.         dataSource.setRemoveAbandoned(removeAbandoned);
  58.         // 超过时间限制多长
  59.         dataSource.setRemoveAbandonedTimeout(removeAbandonedTimeout);
  60.  
  61.         // 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
  62.         dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
  63.         // 配置一个连接在池中最小生存的时间，单位是毫秒
  64.         dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
  65.         // 用来检测连接是否有效的sql，要求是一个查询语句
  66.         dataSource.setValidationQuery(validationQuery);
  67.         // 申请连接的时候检测
  68.         dataSource.setTestWhileIdle(testWhileIdle);
  69.         // 申请连接时执行validationQuery检测连接是否有效，配置为true会降低性能
  70.         dataSource.setTestOnBorrow(testOnBorrow);
  71.         // 归还连接时执行validationQuery检测连接是否有效，配置为true会降低性能
  72.         dataSource.setTestOnReturn(testOnReturn);
  73.         // 打开PSCache，并且指定每个连接上PSCache的大小
  74.         dataSource.setPoolPreparedStatements(poolPreparedStatements);
  75.         dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
  76.         // 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：
  77.         // 监控统计用的filter:stat
  78.         // 日志用的filter:log4j
  79.         // 防御SQL注入的filter:wall
  80.         try {
  81.             dataSource.setFilters(filters);
  82.         } catch (SQLException e) {
  83.             e.printStackTrace();
  84.         }
  85.     }
  86.  
  87.     public String getUrl() {
  88.         return url;
  89.     }
  90.  
  91.     public void setUrl(String url) {
  92.         this.url = url;
  93.     }
  94.  
  95.     public String getUsername() {
  96.         return username;
  97.     }
  98.  
  99.     public void setUsername(String username) {
  100.         this.username = username;
  101.     }
  102.  
  103.     public String getPassword() {
  104.         return password;
  105.     }
  106.  
  107.     public void setPassword(String password) {
  108.         this.password = password;
  109.     }
  110.  
  111.     public String getDriverClassName() {
  112.         return driverClassName;
  113.     }
  114.  
  115.     public void setDriverClassName(String driverClassName) {
  116.         this.driverClassName = driverClassName;
  117.     }
  118.  
  119.     public Integer getInitialSize() {
  120.         return initialSize;
  121.     }
  122.  
  123.     public void setInitialSize(Integer initialSize) {
  124.         this.initialSize = initialSize;
  125.     }
  126.  
  127.     public Integer getMinIdle() {
  128.         return minIdle;
  129.     }
  130.  
  131.     public void setMinIdle(Integer minIdle) {
  132.         this.minIdle = minIdle;
  133.     }
  134.  
  135.     public Integer getMaxActive() {
  136.         return maxActive;
  137.     }
  138.  
  139.     public void setMaxActive(Integer maxActive) {
  140.         this.maxActive = maxActive;
  141.     }
  142.  
  143.     public Integer getMaxWait() {
  144.         return maxWait;
  145.     }
  146.  
  147.     public void setMaxWait(Integer maxWait) {
  148.         this.maxWait = maxWait;
  149.     }
  150.  
  151.     public Integer getTimeBetweenEvictionRunsMillis() {
  152.         return timeBetweenEvictionRunsMillis;
  153.     }
  154.  
  155.     public void setTimeBetweenEvictionRunsMillis(Integer timeBetweenEvictionRunsMillis) {
  156.         this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
  157.     }
  158.  
  159.     public Integer getMinEvictableIdleTimeMillis() {
  160.         return minEvictableIdleTimeMillis;
  161.     }
  162.  
  163.     public void setMinEvictableIdleTimeMillis(Integer minEvictableIdleTimeMillis) {
  164.         this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
  165.     }
  166.  
  167.     public String getValidationQuery() {
  168.         return validationQuery;
  169.     }
  170.  
  171.     public void setValidationQuery(String validationQuery) {
  172.         this.validationQuery = validationQuery;
  173.     }
  174.  
  175.     public Boolean getTestWhileIdle() {
  176.         return testWhileIdle;
  177.     }
  178.  
  179.     public void setTestWhileIdle(Boolean testWhileIdle) {
  180.         this.testWhileIdle = testWhileIdle;
  181.     }
  182.  
  183.     public Boolean getTestOnBorrow() {
  184.         return testOnBorrow;
  185.     }
  186.  
  187.     public void setTestOnBorrow(Boolean testOnBorrow) {
  188.         this.testOnBorrow = testOnBorrow;
  189.     }
  190.  
  191.     public Boolean getTestOnReturn() {
  192.         return testOnReturn;
  193.     }
  194.  
  195.     public void setTestOnReturn(Boolean testOnReturn) {
  196.         this.testOnReturn = testOnReturn;
  197.     }
  198.  
  199.     public Boolean getPoolPreparedStatements() {
  200.         return poolPreparedStatements;
  201.     }
  202.  
  203.     public void setPoolPreparedStatements(Boolean poolPreparedStatements) {
  204.         this.poolPreparedStatements = poolPreparedStatements;
  205.     }
  206.  
  207.     public Integer getMaxPoolPreparedStatementPerConnectionSize() {
  208.         return maxPoolPreparedStatementPerConnectionSize;
  209.     }
  210.  
  211.     public void setMaxPoolPreparedStatementPerConnectionSize(Integer maxPoolPreparedStatementPerConnectionSize) {
  212.         this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
  213.     }
  214.  
  215.     public String getFilters() {
  216.         return filters;
  217.     }
  218.  
  219.     public void setFilters(String filters) {
  220.         this.filters = filters;
  221.     }
  222.  
  223.     public Boolean getRemoveAbandoned() {
  224.         return removeAbandoned;
  225.     }
  226.  
  227.     public void setRemoveAbandoned(Boolean removeAbandoned) {
  228.         this.removeAbandoned = removeAbandoned;
  229.     }
  230.  
  231.     public Integer getRemoveAbandonedTimeout() {
  232.         return removeAbandonedTimeout;
  233.     }
  234.  
  235.     public void setRemoveAbandonedTimeout(Integer removeAbandonedTimeout) {
  236.         this.removeAbandonedTimeout = removeAbandonedTimeout;
  237.     }
  238. }

在entity下创建实体类

  1. @Entity
  2. @Table(name = "books")
  3. @Data
  4. public class Book implements Serializable {
  5.     private static final long serialVersionUID = 1L;
  6.  
  7.     @Id
  8.     @GeneratedValue(strategy = GenerationType.AUTO)
  9.     @Column(name = "book_id")
  10.     private int bookId;
  11.     @Column(name = "title")
  12.     private String title;
  13.     @Column(name = "category")
  14.     private String category;
  15. }

创建在repository下创建Dao层接口和在impl下创建Dao实现类

  1. public interface BookDao {
  2.     List<Book> getAllBooks();
  3.  
  4.     Book getBookById(int bookId);
  5.  
  6.     void addBook(Book book);
  7.  
  8.     void updateBook(Book book);
  9.  
  10.     void deleteBook(int bookId);
  11.  
  12.     boolean bookExists(String title,String category);
  13. }

  1. @Repository
  2. public class IBookDao implements BookDao {
  3.     @PersistenceContext
  4.     private EntityManager entityManager;
  5.  
  6.     @Override
  7.     public List<Book> getAllBooks() {
  8.         String sql = "FROM Book as book ORDER BY book.bookId";
  9.         return (List<Book>)entityManager.createQuery(sql).getResultList();
  10.     }
  11.  
  12.     @Override
  13.     public Book getBookById(int bookId) {
  14.         return entityManager.find(Book.class,bookId);
  15.     }
  16.  
  17.     @Override
  18.     public void addBook(Book book) {
  19.         entityManager.persist(book);
  20.     }
  21.  
  22.     @Override
  23.     public void updateBook(Book book) {
  24.         Book book1 = getBookById(book.getBookId());
  25.         book1.setTitle(book.getTitle());
  26.         book1.setCategory(book.getCategory());
  27.         entityManager.flush();
  28.         entityManager.clear();
  29.     }
  30.  
  31.     @Override
  32.     public void deleteBook(int bookId) {
  33.         entityManager.remove(getBookById(bookId));
  34.     }
  35.  
  36.     @Override
  37.     public boolean bookExists(String title, String category) {
  38.         String sql = "FROM Book as book WHERE book.title=?0 and book.category=?1";
  39.         int count = entityManager.createQuery(sql)
  40.                 .setParameter(0,title)
  41.                 .setParameter(1,category)
  42.                 .getResultList().size();
  43.         return count > 0;
  44.     }
  45. }

创建业务层Service,注入BookDao

  1. @Service
  2. public class BookService {
  3.  
  4.     @Autowired
  5.     private BookDao bookDao;
  6.  
  7.     public Book getBookById(int bookId){
  8.         Book book= bookDao.getBookById(bookId);
  9.         return book;
  10.     }
  11.  
  12.     public List<Book> getAllBooks(){
  13.         return bookDao.getAllBooks();
  14.     }
  15.  
  16.     public synchronized boolean addBook(Book book){
  17.         if(bookDao.bookExists(book.getTitle(),book.getCategory())){
  18.             return false;
  19.         }else {
  20.             bookDao.addBook(book);
  21.             return true;
  22.         }
  23.     }
  24.     public void updateBook(Book book){
  25.         bookDao.updateBook(book);
  26.     }
  27.  
  28.     public void deleteBook(int bookId){
  29.         bookDao.deleteBook(bookId);
  30.     }
  31. }

测试类 编写测试代码

再上图中测试类下编写以下代码

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. @Transactional
  4. public class HibernateApplicationTests {
  5.  
  6.     @Autowired
  7.     private BookService bookService;
  8.  
  9.     @Test
  10.     @Rollback(false)
  11.     public void contextLoads() {
  12.         Book book = bookService.getBookById(1);
  13.         assertThat(book.getTitle(),is("123"));
  14.  
  15.         List<Book> list = bookService.getAllBooks();
  16.         assertThat(list,notNullValue());
  17.         assertThat(list.size(), is(3));
  18.         boolean flag = bookService.addBook(book);
  19.         assertThat(flag, is(false));
  20.  
  21.         book.setTitle("012");
  22.         bookService.updateBook(book);
  23.         Book book1 = bookService.getBookById(1);
  24.         System.out.println(book1);
  25.         assertThat(book1.getTitle(), is("012"));
  26.  
  27.  
  28.         bookService.deleteBook(1);
  29.         Book article2 = bookService.getBookById(1);
  30.         assertThat(article2, nullValue());
  31.     }
  32.  
  33. }

依次执行上面测试代码中的增删改查。根据数据库和控制台输出查看结果是否测试通过。简单的集成Hibernate已经完成。更多可以了解JPA复杂语句查询以及根据实体类自动创建数据库。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/爱喝兽奶帝天荒/article/detail/815314
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号