一文教会你如何在SpringBoot项目里集成Hibernate_springboot hibernate

前言

一个老项目中使用了Hibernate，是SpringMVC项目，要把定时任务拆出来，使用SpringBoot集成Hibernate，今天整理下集成的过程。

基础概念

什么是Hibernate

Hibernate是一个流行的ORM（对象关系映射）框架，它可以将Java对象映射到数据库表，从而方便地进行持久化操作。

在Spring Boot项目中，集成Hibernate可以帮助我们更轻松地进行数据库操作。

Hibernate 的主要功能

1.对象关系映射（ORM）：Hibernate可以自动将Java类和对象映射到关系数据库中的表和行。

2.透明持久性：Hibernate可以自动管理对象的生命周期，并将其持久化到数据库中，从而使开发人员可以专注于业务逻辑，而不必担心对象的状态管理。

3.查询语言：Hibernate提供了一种基于面向对象的查询语言（HQL），使开发人员可以使用面向对象的方式来查询和操作数据库。

4.缓存管理：Hibernate提供了一个高效的缓存管理机制，可以提高应用程序的性能。

5.事务管理：Hibernate可以自动管理数据库事务，从而确保数据的完整性和一致性。

使用Hibernate的好处

1.简化数据访问层：Hibernate简化了数据访问层的开发，开发人员只需要关注业务逻辑，而不必编写繁琐的SQL语句。

2.提高开发效率：Hibernate可以自动生成数据库表和列，省去了手动创建和维护数据库表的麻烦。此外，Hibernate还提供了一种基于对象的查询语言，使得查询和操作数据变得更加简单。

3.提高可维护性：Hibernate使得应用程序的代码更加清晰、简单易懂，使得应用程序更加易于维护。

4.支持多种数据库：Hibernate可以很方便地支持多种关系数据库，包括MySQL、Oracle、Microsoft SQL Server等。

5.提高性能：Hibernate提供了一个缓存机制，可以提高应用程序的性能。此外，Hibernate还支持批量处理和延迟加载等优化技术，可以进一步提高应用程序的性能。

6.支持事务管理：Hibernate可以自动管理数据库事务，从而确保数据的完整性和一致性。开发人员可以专注于业务逻辑，而不必手动处理事务。

添加依赖

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

<dependency>
    <groupId>org.hibernate.common</groupId>
    <artifactId>hibernate-commons-annotations</artifactId>
    <version>4.0.4.Final</version>
</dependency>
1
2
3
4
5
6
7
8
9
10

使用SessionFactory

我们这个老项目中使用 SessionFactory，所以这里整合了SessionFactory 用作数据库增删改查。

配置文件

spring:
  datasource:
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:oracle:thin:@ip:1521:ORCL
    username: test
    password: test
    hikari:
      maximum-pool-size: 30

  jpa:
    database: oracle
    hibernate:
      hbm2ddl_auto: none
      dialect: org.hibernate.dialect.OracleDialect
      show_sql: false
      format_sql: false
      use_jdbc_metadata_defaults: false
      default-schema: ${spring.datasource.username}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class HibernateSessionConfig {

    @Autowired
    private HibernateConfig hibernateConfig;


    @Autowired
    @Bean("sessionFactory")
    public LocalSessionFactoryBean getSessionFactory(DataSource dataSource) {
        return buildLocalSessionFactory(dataSource);

    }

    /**
     * 设置Hibernate的配置属性
     * @return
     */
    private Properties getHibernateProperties(){
        Properties hibernateProperties = new Properties();
        hibernateProperties.put("hibernate.dialect",hibernateConfig.getDialect());
        hibernateProperties.put("default_schema",hibernateConfig.getDefaultSchema());
        hibernateProperties.put("hibernate.show_sql", hibernateConfig.getShowSql());
        hibernateProperties.put("hibernate.format_sql", hibernateConfig.getFormatSql());
        hibernateProperties.put("hibernate.hbm2ddl.auto", hibernateConfig.getHbm2ddlAuto());
        hibernateProperties.put("hibernate.temp.use_jdbc_metadata_defaults", hibernateConfig.getUseJdbcMetadataDefaults());
        return hibernateProperties;

    }

    /**
     * 构建LocalSessionFactoryBean实例
     * @param dataSource 构建实例所使用的的数据源
     * @return
     */
    private LocalSessionFactoryBean buildLocalSessionFactory(DataSource dataSource){
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setPackagesToScan("org.teamartframework.*","jdly.water.*");
        sessionFactory.setHibernateProperties(getHibernateProperties());
        return sessionFactory;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

@ConfigurationProperties(
        prefix = "spring.jpa.hibernate"
)
@Component
@Data
public class HibernateConfig {

    private String dialect;


    private String showSql;

    private String formatSql;

    private String hbm2ddlAuto;

    private String useJdbcMetadataDefaults;

    private String defaultSchema;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

创建Dao层

@Repository
public class CommonDao{
    
    @Autowired
	@Qualifier("sessionFactory")
	private SessionFactory sessionFactory;
    
    public Session getSession() {
        // 事务必须是开启的(Required)，否则获取不到
        return sessionFactory.getCurrentSession();
	}
    
    
	/**
	 * 根据传入的实体持久化对象
	 */
	public <T> Serializable save(T entity) {
		try {
			Serializable id = getSession().save(entity);
			getSession().flush();
			if (logger.isDebugEnabled()) {
				logger.debug("保存实体成功," + entity.getClass().getName());
			}
			return id;
		} catch (RuntimeException e) {
			logger.error("保存实体异常", e);
			throw e;
		}

	}
    
    	/**
	 * 根据Id获取对象。
	 */
	public <T> T get(Class<T> entityClass, final Serializable id) {

		return (T) getSession().get(entityClass, id);

	}
    
    	/**
	 * 根据主键更新实体
	 */
	public <T> void updateEntityById(Class entityName, Serializable id) {
		updateEntitie(get(entityName, id));
	}
    
    	/**
	 * 根据主键删除指定的实体
	 * 
	 * @param <T>
	 * @param pojo
	 */
	public <T> void deleteEntityById(Class entityName, Serializable id) {
		delete(get(entityName, id));
		getSession().flush();
	}
    /**
	 * 执行自定义sql
	 * 
	 * @param <T>
	 * @param pojo
	 */
    public List<Map<String, Object>> findToMapList(String sql) {
        Query query = getSession().createSQLQuery(sql);
        List<Map<String, Object>>  lst = new ArrayList();
        try {
            query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
            lst = query.list();
        } catch (HibernateException e) {
            e.printStackTrace();
        } finally {

        }
        return lst;
	 }
    
    
  	/**
	 * 返回实体
	 * @param sql
	 * @param clazz
	 * @param param 
	 * @return
	 */
	public List<T> find(String sql,Class clazz, Object... param){
		Query query = null;
		query = getSession().createSQLQuery(sql).addEntity(clazz); //返回实体类的方法
		if (param != null && param.length > 0) {
			for (int i = 0; i < param.length; i++) {
				query.setParameter(i, param[i]);
			}
		}
		return query.list();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

使用Repository访问数据库

依赖和上面引入的一样，这里就不在重复了。

配置数据源

server:
  port: 8030
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://ip:3306/test?useSSL=false&serverTimezone=UTC
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: none

    database: mysql
    database-platform: org.hibernate.dialect.MySQLDialect
    show-sql: true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Spring.jpa.hibernate.ddl-auto属性指定了Hibernate如何自动生成数据库表，create-drop表示每次启动应用程序时都会创建表，并在关闭应用程序时删除表。

none表示不用更新。

创建实体类

@Entity
@Table(name = "person")
@Data
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private int age;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

创建Repository

@Repository
public interface PersonRepository extends JpaRepository<Person, Long> {
    
    @Query("select t from Person t where t.name like :name")
    public List<Person> findUserByName(@Param("name") String name);
}
1
2
3
4
5
6

业务类

@Service
public class PersonService {

    @Autowired
    private PersonRepository personRepository;

    public void savePerson(Person person) {
        personRepository.save(person);
    }

    public List<Person> getPersons() {
        return personRepository.findAll();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

接口类

@RestController
public class PersionController {

    @Autowired
    private PersonService personService;

    @GetMapping("save")
    public String save(){
        Person person = new Person();
        person.setName("zhangsan");
        personService.savePerson(person);
        return "hello world";
    }

    @GetMapping("get")
    public List<Person> get(String name){
        return personService.findUserByName(name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

总结

我们已经成功地在Spring Boot项目中集成了Hibernate，并且可以使用它来方便地进行数据库操作。当然，在实际的项目中，可能需要进行更复杂的配置和操作，但这个示例应该可以让你快速入门。