如何连接harbor的数据库 hibernate连接数据库步骤

1：创建实体类

1 package com.yinfu.entity;
 2 
 3 public class User {
 4 
 5     private int id;
 6     private String username;
 7     private String password;
 8     private String address;
 9     public int getId() {
10         return id;
11     }
12     public void setId(int id) {
13         this.id = id;
14     }
15     public String getUsername() {
16         return username;
17     }
18     public void setUsername(String username) {
19         this.username = username;
20     }
21     public String getPassword() {
22         return password;
23     }
24     public void setPassword(String password) {
25         this.password = password;
26     }
27     public String getAddress() {
28         return address;
29     }
30     public void setAddress(String address) {
31         this.address = address;
32     }
33     
34 }

User.Java

2：创建实体类与数据库表对应的配置文件：

1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping>
 6 <!-- 
 7     配置类和表的对应
 8     class标签
 9     name属性：实体类全类名
10     table属性：数据库表名称,用hibernate不需要自己创建表，他可以根据配置文件自动生成数据库表
11  -->
12  <class name="com.yinfu.entity.User" table="t_user">
13      <!-- 
14          配置实体类ID与表中的ID进行对应
15          hibernate要求实体类属性有一个唯一值
16          hibernate要求表有作为唯一值得字段
17       -->
18       <!--id标签
19            name属性：实体类中的id名称
20            column属性：表字段中的id名称
21        -->
22        <id name="id" column="id">
23            <!-- 设置数据库表的增长策略
24                native:生成表id值就是主键自增长
25             -->
26            <generator class="native"></generator>
27        </id>
28        <!-- 配置其他属性和表的字段的对应
29                name属性：实体类中的属性名
30                column属性：表中的字段名
31         -->
32        <property name="username" column="username"></property>
33        <property name="password" column="password"></property>
34        <property name="address" column="address"></property>
35  </class>
36 </hibernate-mapping>

User.hbm.xml

3：hibernate核心配置文件（1.数据库信息，2.hibernate信息，3.实体类与数据库映射的配置文件注入信息）

此配置文件文件名和位置是固定的：文件名：hibernate.cfg.xml 位置：要放在src文件夹下

1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6 <!-- 此配置文件的文件名和位置是固定的的
 7     文件名：hibernate.cfg.xml
 8     位置：要写在src文件中
 9  -->
10     <session-factory>
11         <!-- 第一部分：配置数据库信息 -->
12         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
13         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
14         <property name="hibernate.connection.username">root</property>
15         <property name="hibernate.connection.password">song12345</property>
16         
17         <!-- 第二部分：配置hibernate信息（可有可无） -->
18         <!-- 输出底层的SQL语句 -->
19         <property name="hibernate.show_sql">true</property>
20         <!-- 对底曾语句进行格式化 -->
21         <property name="hibernate.format_sql">true</property>
22         <!-- hibernate帮创建表，需要配置
23             update：如果有表就更新，没有表就创建
24          -->
25         <property name="hibernate.hbm2ddl.auto">update</property>
26         <!-- 配置数据库的方言 
27             识别不同数据库中的特有的语句和关键字
28             比如：分页查询
29                     MySQL关键字是limit
30                     oracle中的使用的是top-n分析中的rownum
31         -->
32         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
33         <!-- 指定线程管理方式，与本地线程进行绑定，实现单线程操作 -->
34         <property name="hibernate.current_session_context_class">thread</property>
35     
36         <!-- 第三部分：把映射文件放到核心配置文件中 -->
37         <mapping resource="com/yinfu/entity/User.hbm.xml"/>
38     
39     </session-factory>
40     
41 </hibernate-configuration>

hibernate.cfg.xml

4：用Junit进行简单测试：

1 package com.yinfu.test;
 2 
 3 import static org.junit.Assert.*;
 4 
 5 import org.hibernate.Session;
 6 import org.hibernate.SessionFactory;
 7 import org.hibernate.Transaction;
 8 import org.hibernate.cfg.Configuration;
 9 import org.junit.Test;
10 
11 import com.yinfu.entity.User;
12 import com.yinfu.utils.HibernateUtils;
13 
14 public class HibernateTest {
15 
16     @Test
17     public void test() {
18         //1.加载hibernate核心配置文件
19         //只会到src下去寻找hibernate的核心配置文件
20         Configuration cfg = new Configuration();
21         cfg.configure();
22         //2.创建sessionFactory对象
23         //读取hibernate核心配置文件内容，根据configuration对象创建sessionFactory对象
24         //在这过程中，根据映射关系，在相应数据库中把表创建
25         SessionFactory sessionFactory = cfg.buildSessionFactory();
26         //3.根据sessionFactory得到session对象
27         //类似于jdbc中的connection链接
28         Session session = sessionFactory.openSession();
29         //4.开启事务
30         Transaction tx = session.beginTransaction();
31         //5.逻辑代码实现crud操作
32         //session中有：增加：save方法   修改：update  删除：delete方法    根据ID查询：get方法
33         User user = new User();
34         user.setUsername("李四");
35         user.setPassword("12345");
36         user.setAddress("韩国");
37         session.save(user);
38         //6.提交事务
39         tx.commit();
40         //7.释放资源
41         session.close();
42         sessionFactory.close();
43         
44     }
45 }

test

4.1，将创建SessionFactory对象的代码提出来，放到static静态代码块中，当此类加载的时候只创建一个对象，并重复使用此对象，能够进行优化

首先创建Utils工具类：

1 package com.yinfu.utils;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.cfg.Configuration;
 6 
 7 //工具类
 8 public class HibernateUtils {
 9 
10     private final static Configuration cfg;
11     private final static SessionFactory sessionFactory;
12     
13     //用静态代码块来实现对象只在类加载的时候创建一次(静态代码块只执行一次)
14     static{
15         //创建configuration对象，
16         cfg = new Configuration();
17         cfg.configure();
18         //根据Configuration对象创建sessionFactory对象
19         sessionFactory = cfg.buildSessionFactory();
20     }
21     
22     //返回与本地线程绑定的session
23     public static Session getSession(){
24         return sessionFactory.getCurrentSession();
25     }
26     
27     //创建一个方法用于返回sessionFactory对象
28     public static SessionFactory getSessionFactory(){
29         return sessionFactory;
30     }
31     
32     
33 }

HibernateUtils

然后创建测试类：

1 package com.yinfu.test;
 2 
 3 import static org.junit.Assert.*;
 4 
 5 import org.hibernate.Session;
 6 import org.hibernate.SessionFactory;
 7 import org.hibernate.Transaction;
 8 import org.hibernate.cfg.Configuration;
 9 import org.junit.Test;
10 
11 import com.yinfu.entity.User;
12 import com.yinfu.utils.HibernateUtils;
13 
14 public class HibernateTest {
15     @Test
16     public void testStatic() {
17         //利用工具类得到与本地线程绑定的session
18         Session session = HibernateUtils.getSession();
19         //4.开启事务
20         Transaction tx = session.beginTransaction();
21         //5.逻辑代码
22         //增加方法：
23         //此user为瞬时态数据（user中没有id，与session无关）
24         User user = new User();
25         user.setUsername("赵六");
26         user.setPassword("12345");
27         user.setAddress("玛雅文明");
28         session.save(user);
29         
30         //根据ID查询：
31         //第一个参数：实体类的类对象。第二个参数：id值
32         //此user为持久态数据（有id，与session有关）
33 //        User user = session.get(User.class, 1);
34 //        System.out.println(user);
35         
36         //修改方法:
37 //        User user = session.get(User.class, 1);
38 //        user.setUsername("张三");
39 //        session.update(user);
40         
41         //删除方法：
42         //第一种：
43 //        User user = session.get(User.class, 1);
44 //        session.delete(user);
45         //第二种：
46 //        User user = new User();
47 //        user.setId(2);
48 //        session.delete(user);
49         
50         //6.提交事务
51         tx.commit();
52         //7.释放资源
53         session.close();
54         
55     }
56 
57 }

test由于在工具类中将session与当前线程进行了绑定，执行结果正确了，但是会有一个异常，这个异常是由于当session与本地线程进行绑定之后，session会随着线程的结束而自动关闭，不在需要手动进行session关闭，当还有session.close()方法的时候回报此异常。

 

 数据的三种状态：

1：瞬时态数据（没有ID，与session无关）：

User user = new User();
user.setUsername("赵六");
user.setPassword("12345");
user.setAddress("玛雅文明");

2：脱管状态：（有id，与session无关）

User user = new User();

user.setId(1);

3:持久态数据：（有id，与session有关）

User user = session.get(User.class, 1);