目录
ORM映射（Object Relational Mapping）
CRM
什么是CRM
CRM（Customer Relationship Management）客户关系管理，是利用相应的信息技术以及互联网技术来协调企业与顾客间在销售、营销和服务上的交互，向客户提供创新式的个性化的客户交互和服务的过程。
其最终目标是将面向客户的各项信息和活动集成起来，组建一个以客户为中心的企业，实现对面向客户的活动等全面管理。
CRM的模块
CRM系统实现了对企业销售、营销、服务等各阶段的客户信息、客户活动进行统一管理。
CRM系统功能涵盖企业销售、营销、用户服务等各各业务流程，业务流程中与客户相关活动都会在CRM系统统一管理。
基本的模块功能，包括：
- 客户信息管理
- 联系人管理
- 商机管理
- 统计分析等
模块的具体功能
- 客户信息管理——对客户信息统一维护，客户是指存量客户或拟营销的客户，提供员工录入形成公司的“客户库”是公司最重要的数据资源。
- 联系人管理——对客户的联系人信息统一管理，联系人是指客户企业的联系人，即企业的业务人员和客户的哪些人在打交道。
- 客户拜访管理——业务要开发客户需要去拜访客户，客户拜访信息记录了业务员与客户沟通交流方面的不足、采取的策略不当、有待改进的地方或值得分享的沟通技巧等方面的信息。
- 系统管理——系统管理属于crmxit基础功能模块，包括：数据字典、账户管理、角色管理、权限管理、操作日志管理等。
Hibernate概述（了解）
Hibernate框架的概述
Hibernate是一个开放源代码的对象关系映射（ORM）框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java客户端程序使用，也可以在Servlet/Jsp的web应用中使用。
Hibernate是轻量级JavaEE应用的持久层解决方案，是一个关系数据库ORM框架
Hibernate是一个持久层的ORM框架
什么是ORM（对象关系映射）
ORM映射（Object Relational Mapping）
- O：面对对象的领域的Object（JavaBean对象）
- R：关系数据库领域的Relational（表的结构）
- M：映射Mapping（XML的配置文件）
将数据库表的关系，映射为类和对象之间的关系：
| 数据库（关系型） | Java（面向对象的编程语言） |
| 表 | 类 |
| 表的字段 | 类的属性 |
| 表的一行数据 | 类的一个实例对象 |
Hibernate使程序员通过操作对象的方式来操作数据库表记录
Hibernate优点
Hibernate对JDBC访问数据库代码做了封装，大大简化了数据访问层繁琐的重复性代码。
Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的orm实现，它很大程度的简化了dao层编码工作。
Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系。
Hibernate快速入门
hibernate的jar包下载和导入
1.下载相应的jar包等
2.解压后对目录结构有一定的了解
hibernate开发包内容：
documentation-文档
lib-jar包
project-项目例子
optional-可选jar包
required-必选jar包
3.jar包的导入（开发环境的搭建）
新建web工程，引入所需jar包
- MySQL的驱动jar包
- hibernate开发所需的包（lib/required/所有jar包）
开发准备和配置（三个准备，7个步骤）
【第一个准备】创建表结构
【第二个准备】编写Hibernate核心的配置文件
1.在src目录下，创建名为hibernate.cfg.xml的配置文件
2.在XML中引入DTD约束
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">3.打开hibernate-release-5.4.4.Final/project/etc/hibernate.properties可以查看具体的配置信息
- 必须配置的4大参数
-
## MySQL
#hibernate.connection.driver_class com.mysql.jdbc.Driver
#hibernate.connection.url jdbc:mysql:///test
#hibernate.connection.username gavin
#hibernate.connection.password - 数据库的方言（必须配置）
#hibernate.dialect org.hibernate.dialect.MySQLDialect
- 可选的配置
#hibernate.show_sql true
#hibernate.format_sql true
#hibernate.hbm2ddl.auto update
- 引入映射配置文件（一定要注意，要引入映射文件，框架需要加载映射文件）
4.配置hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<!-- 配置连接信息 -->
<!-- -->
<session-factory>
<!-- 必选配置 -->
<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 连接的URL -->
<property name="hibernate.connection.url"> jdbc:mysql:///hibernate</property>
<!-- 用户名和密码 -->
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">12345678</property>
<!-- 数据库方言 使用的数据库类型 MySQL -->
<property
name="hibernate.dialect org.hibernate.dialect.MySQLDialect"></property>
<!-- 可选配置 -->
<!-- 映射文件 -->
</session-factory>
</hibernate-configuration>5.测试是否能连上数据库
编写测试类Test
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Test {
@org.junit.Test
public void run() {
// hibernate读取连接数据的配置文件hibernte.cfg.xml
Configuration configuration=new Configuration();
configuration.configure();
//连接数据库 连接池
SessionFactory factory=configuration.buildSessionFactory();
System.out.println(factory);
}
}
测试结果 证明连接成功
【第三个准备】编写实体类和ORM映射文件
编写Customer实体类
package com.feng.domain;
public class Customer {
private Long cust_id;
private String cust_name;
private Long cust_user_id;
private Long cust_create_id;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
public Long getCust_id() {
return cust_id;
}
public void setCust_id(Long cust_id) {
this.cust_id = cust_id;
}
public String getCust_name() {
return cust_name;
}
public void setCust_name(String cust_name) {
this.cust_name = cust_name;
}
public Long getCust_user_id() {
return cust_user_id;
}
public void setCust_user_id(Long cust_user_id) {
this.cust_user_id = cust_user_id;
}
public Long getCust_create_id() {
return cust_create_id;
}
public void setCust_create_id(Long cust_create_id) {
this.cust_create_id = cust_create_id;
}
public String getCust_source() {
return cust_source;
}
public void setCust_source(String cust_source) {
this.cust_source = cust_source;
}
public String getCust_industry() {
return cust_industry;
}
public void setCust_industry(String cust_industry) {
this.cust_industry = cust_industry;
}
public String getCust_level() {
return cust_level;
}
public void setCust_level(String cust_level) {
this.cust_level = cust_level;
}
public String getCust_linkman() {
return cust_linkman;
}
public void setCust_linkman(String cust_linkman) {
this.cust_linkman = cust_linkman;
}
public String getCust_phone() {
return cust_phone;
}
public void setCust_phone(String cust_phone) {
this.cust_phone = cust_phone;
}
public String getCust_mobile() {
return cust_mobile;
}
public void setCust_mobile(String cust_mobile) {
this.cust_mobile = cust_mobile;
}
@Override
public String toString() {
return "Customer [cust_id=" + cust_id + ", cust_name=" + cust_name + ", cust_user_id=" + cust_user_id
+ ", cust_create_id=" + cust_create_id + ", cust_source=" + cust_source + ", cust_industry=" + cust_industry
+ ", cust_level=" + cust_level + ", cust_linkman=" + cust_linkman + ", cust_phone=" + cust_phone
+ ", cust_mobile=" + cust_mobile + "]";
}
}创建类与表结构的映射
1.在JavaBean所在包下创建映射的配置文件
- 默认的命名规则为：实体类名.hbm.xml
- 在xml配置文件中引入约束（引入的是hibernate3.0的dtd约束，不要引入4点约束）
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">2.如果不联网，则没有自动提示，需要自动配置。可看此步骤。
3.编写Customer.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- javabean与表之间的对应关系 -->
<class name="com.feng.domain.Customer" table="cst_customer">
<!-- 主键对应 -->
<id name="cust_id" column="cust_id">
<!-- 主键策略（与自增长相关） -->
<generator class="native"></generator>
</id>
<!-- 其他字段 -->
<property name="cust_name" column="cust_name"></property>
<property name="cust_user_id" column="cust_user_id"></property>
<property name="cust_create_id" column="cust_create_id"></property>
<property name="cust_source" column="cust_source"></property>
<property name="cust_industry" column="cust_industry"></property>
<property name="cust_level" column="cust_level"></property>
<property name="cust_linkman" column="cust_linkman"></property>
<property name="cust_phone" column="cust_phone"></property>
<property name="cust_mobile" column="cust_mobile"></property>
</class>
</hibernate-mapping>4.在hibernate.cfg.xml中引入上述配置文件
<mapping resource="com/feng/domain/Customer.hbm.xml"/>保存（插入）数据
在TestCustomer.java中编写testSave方法保存数据
// 保存一个用户
@Test
public void testSave() {
//1.新建一个用户
Customer customer=new Customer();
customer.setCust_name("张艺兴");
customer.setCust_mobile("15034528573");
//分七个步骤操作数据
//1.加载配置文件，默认是src目录下的hibernate.cfg.xml
Configuration configuration=new Configuration().configure();
//2.创建sessionFactory对象
SessionFactory factory=configuration.buildSessionFactory();
//3.创建session对象,从连接池中获取一个连接
Session session=factory.openSession();
//4.开启事务
Transaction transaction=session.beginTransaction();
//5.保存数据
session.save(customer);
//6.提交事务
transaction.commit();
//7.释放资源
session.close();
factory.close();
}
运行结果
Hibernate常用的配置文件
log4j的简单使用
1.做一个事情
- 导入日志jar包（自行搜索log4j到jar包）
- 把log4j.properties文件拷贝到src目录下就ok（网上也有很大模版）
【什么是slf4j】
SLF4J，即简单日志门面（Simple Logging Facade for Java），不是具体的日志解决方案，它只服务于各种各样的日志系统。按照官方的说法，SLF4J是一个用于日志系统的简单Facade，允许最终用户在部署其应用时使用其所希望的日志System
slf4j-api只是接口包（解耦合的思想，静态绑定思想），需要日志系统的实现log4j
log4j.properties
#
# Hibernate, Relational Persistence for Idiomatic Java
#
# License: GNU Lesser General Public License (LGPL), version 2.1 or later.
# See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
#
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=error, stdout
#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug
### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug
### log just the SQL
log4j.logger.org.hibernate.SQL=debug
### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug
### log schema export/update ###
#log4j.logger.org.hibernate.tool.hbm2ddl=debug
### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug
### log cache activity ###
#log4j.logger.org.hibernate.cache=debug
### log transaction activity
#log4j.logger.org.hibernate.transaction=debug
### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug
### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace
创建TestLog4j类
public class TestLog4j {
Logger logger=Logger.getLogger(TestLog4j.class);
@Test
public void testlog4j() {
System.out.println("sysout 输出的信息");
// 使用log4j打印信息
logger.info("info输出的信息");
}
}
测试结果
当修改log4j.properties
log4j.rootLogger=off, stdout再进行测试，日志已关闭
当然还可以把输出日志信息存入文件，此处略提，自行百度。
配置文件的提示的问题（必须要配置）
上面已说过，联网会有自动提示，不联网则点击配置文件提示问题。
Hibernate配置文件之映射配置文件
1.映射文件，即Customer.hbm.xml的配置文件
- <class>标签——用来将类与数据库表建立映射关系
- name——类的全路径
- table——表名，（类名与表名一致，那么table属性也可以省略）
- catalog———数据库的名称，基本上都会省略不写
- <id>标签——用来将类中的属性与表中的主键建立映射，id标签就是用来配置主键的
- name——类中属性名
- column——表中的字段名，（如果类中的属性名与表中的字段一致，那么column可以省略）
- length——字段的长度，如果数据库已经建好了，那么length可以不写。如果没有建好，生成表结构时，length最好指定。
- <property>——用来将类中的普通属性与表中的字段建立映射
- name——类中属性名
- column——表中字段名，（如果类中的属性名与表字段名一致，那么column可以省略不写）
- length——数据长度
- type——数据类型（一般不需要编写，如果编写需要按照规则来编写）
- Java数据类型——type="java.lang.String"
- 数据库字段的数据类型——<column name="name" sql-type="varchar"/>
Hibernate配置文件之核心配置文件
1.核心配置文件的两种方式（了解）
第一种方式时属性文件的形式，即properties的配置文件
hibernate.properties
hibernate.connection.driver_class=com.mysql.jdbc.Driver
缺点：不能加载映射的配置文件，需要手动编写代码去加载
第二种方式时xml文件的形式，开发基本都会选择这种方式
hibernate.cfg.xml
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
优点：
格式比较清晰
编写有提示
可以在该配置文件中加载映射的配置文件（最主要的0
2.关于hibernate.cfg.xml的配置文件方式
必须有的配置
数据库连接信息：
hibernate.connection.driver_class——连接数据库驱动程序
hibernate.connection.url——连接数据库URL
hibernate.connection.username——连接数据库用户名
hibernate.connection.password——连接数据库密码
hibernate.dialect——操作数据库方言
可选的配置
#hibernate.show_sql ——显示SQL
#hibernate.format_sql ——格式化SQL
#hibernate.hbm2ddl.auto update ——通过映射转成DDL语句
create——每次都会创建一个新的表——测试的时候
create-drop ——每次都会创建一个新的表，当执行结束之后，将创建的这个表删除——测试的时候
update——如果有表，使用原理的表，没有表，创建一个新的表，同时更新表结构
validate——如果有表，使用原来的表，同时校验映射文件与表中字段是否一致，如果不一致就会报错
加载映射——如果是xml方式，<mapping resource="com/feng/domain/Customer.hbm.xml"/>
控制台打印SQL
在hibernate.cfg.xml配置
<!-- 显示sql -->
<property name="hibernate.show_sql ">true</property>
<!-- 格式化sql -->
<property name="hibernate.format_sql ">true</property>
<!-- 自动注释 -->
<property name="use_sql_comments">true</property>再重新运行，测试结果（没有格式化没有注释，俺也不知道为啥，先记下）
10:09:57,400 DEBUG SQL:103 - /* insert com.feng.domain.Customer */ insert into cst_customer (cust_name, cust_user_id, cust_create_id, cust_source, cust_industry, cust_level, cust_linkman, cust_phone, cust_mobile) values (?, ?, ?, ?, ?, ?, ?, ?, ?)
Hibernate框架整合C3P0连接池
1.导入c3p0的jar包（在可选包内）
2.在hibernate.cfg.xml的配置文件中编写配置
<!-- c3p0供应商 -->
<property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
<!-- 最小连接 -->
<property name="hibernate.c3p0.min_size">5</property>
<!-- 最大连接数 -->
<property name="hibernate.c3p0.max_size">10</property>
<!-- 每120秒检查空闲连接 -->
<property name="hibernate.c3p0.timeout">120</property>再次测试，把日志输出调成info
自动建表
该配置是让hibernate是否自动建立相应的表，也就是说，数据库可以没有表，hibernate自动创建
- create-drop：在程序运行时，（创建session工厂的时候）会自动建表，在程序停止是（关闭sessionFactory时），表删除。
直接使用debug方式，断点查看（做这种测试之前先把表备份啊）
首先，表里有数据
设置断点
debug模式运行
第一步，观察表是否创建成功（标志，原先的表被删除，数据丢失）
第二步：实现保存操作，观察表中是否有数据
第三步：程序运行结束，观察表是否被删除
1.创建表
create table cst_customer (cust_id bigint not null auto_increment, cust_name varchar(255), cust_user_id bigint, cust_create_id bigint, cust_source varchar(255), cust_industry varchar(255), cust_level varchar(255), cust_linkman varchar(255), cust_phone varchar(255), cust_mobile varchar(255), primary key (cust_id)) engine=InnoDB2.往下走，插入数据
insert into cst_customer (cust_name, cust_user_id, cust_create_id, cust_source, cust_industry, cust_level, cust_linkman, cust_phone, cust_mobile) values (?, ?, ?, ?, ?, ?, ?, ?, ?)
3.表删除
- create：在程序运行时，如果表不存在，自动建表，如果存在，则不进行任何操作（mysql会先删除再创建）
修改hibernate.cfg.xml文件
<!-- 自动建表 -->
<property name="hibernate.hbm2ddl.auto">create</property>运行程序
注意，再次运行程序，发现表里的记录还是一条数据，说明创建该表前，如果存在该表，会先把该表删除，再创建新表，再插入记录。
- update：在程序运行时，如果表不存在，自动建表，如果表存在，则检查表和类结构是否一致，如果不一致，则更新表结构（推荐）
修改hibernate.cfg.xml
<!-- 自动建表 -->
<property name="hibernate.hbm2ddl.auto">update</property>在Customer.java增加地址属性
//增加地址
private String cust_address;
public String getCust_address() {
return cust_address;
}
public void setCust_address(String cust_address) {
this.cust_address = cust_address;
}修改Customer.hbm.xml,增加一下内容
<property name="cust_address" column="cust_address"></property>在测试类增加方法
@Test
public void testSave1() {
//1.新建一个用户
Customer customer=new Customer();
customer.setCust_name("张艺兴");
customer.setCust_mobile("15034528573");
customer.setCust_address("长沙");
//分七个步骤操作数据
//1.加载配置文件，默认是src目录下的hibernate.cfg.xml
Configuration configuration=new Configuration().configure();
//2.创建sessionFactory对象
SessionFactory factory=configuration.buildSessionFactory();
//3.创建session对象,从连接池中获取一个连接
Session session=factory.openSession();
//4.开启事务
Transaction transaction=session.beginTransaction();
//5.保存数据
session.save(customer);
//6.提交事务
transaction.commit();
//7.释放资源
session.close();
factory.close();
}
运行程序（发现表增加地址字段）
- validate——验证Javabean和表是否对应
1.首先把表中的地址字段删除
ALTER TABLE `hibernate`.`cst_customer`
DROP COLUMN `cust_address`;
2.修改hibernate.cfg.xml
<property name="hibernate.hbm2ddl.auto">validate</property>3.测试上一个方法，报错
技术分析之Hibernate常用的接口和类
Configuration类和作用
1.Configuration类
- Configuration对象用于配置且启动Hibernate
- Hibernate应用通过该对象来获取对象-关系映射文件中的元数据，以及动态配置Hibernate的属性，然后创建SessionFactory对象
简单一句话，加载Hibernate的配置文件，可以获取SessionFactory对象
2.Configuration类的其他应用（了解）
- 加载配置文件当的种类，HIbernate支持xml和properties类型的配置文件，在开发中基本都使用XM配置文件的方式
- 如果采用的是properties的配置文件，那么通过Configuration configuration=new Configuration（）；就可以加载配置文件，但是需要手动加载映射文件，例如：config.addResource("com/feng/domain/Customer.hbm.xml");
- 如果采用的XML的配置文件，通过Configuration configuration=new Configuration().configure();加载配置文件
SessionFactory接口
1. 是工厂类，是生成Session对象的工厂类
2. SessionFactory类的特点
- 由Configuration通过加载配置文件创建该对象。
- SessionFactory对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句。同时，SessionFactory还负责维护Hibernate的二级缓存。
- 预定义SQL语句
- 使用Configuration类创建了SessionFactory对象是，已经在SessionFacotry对象中缓存了一些SQL语句
- 常见的SQL语句是增删改查（通过主键来查询）
- 这样做的目的是效率更高
- 一个SessionFactory实例对应一个数据库，应用从该对象中获得Session实例。
- SessionFactory是线程安全的，意味着它的一个实例可以被应用的多个线程共享。
- SessionFactory是重量级的，意味着不能随意创建或销毁它的实例。如果只访问一个数据库，只需要创建一个SessionFactory实例，且在应用初始化的时候完成。
- SessionFactory需要一个较大的缓存，用来存放预定义的SQL语句及实体的映射信息。另外可以配置一个缓存插件，这个插件被称之为Hibernate的二级缓存，被多线程所共享
3. 总结
- 一般应用使用一个SessionFactory,最好是应用启动时就完成初始化。
编写HibernateUtil的工具类
package com.feng.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
// 使用一个静态块创建SessionFactory
private static final Configuration CONFIG;
private static final SessionFactory FACTORY;
static {
CONFIG = new Configuration().configure();
FACTORY = CONFIG.buildSessionFactory();
}
// 从连接池获取连接
public static Session openSession() {
return FACTORY.openSession();
}
}
在测试类中增加测试方法
@Test
public void testSave2() {
Customer customer=new Customer();
customer.setCust_name("王一博");
customer.setCust_address("河南");
//通过Session保存数据
Session session=HibernateUtil.openSession();
Transaction transaction=session.beginTransaction();
session.save(customer);
transaction.commit();
session.close();
}修改hibernate.cfg.xml
<property name="hibernate.hbm2ddl.auto">update</property>测试结果
Session接口
1. 概述
- Session是在Hibernate中使用最频繁的接口。也被称之为持久化管理器。它提供了和持久化有关的操作，比如添加、修改、删除、加载和查询实体对象
- Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心
- Session是线程不安全的
- 所有持久化对象必须在 session 的管理下才可以进行持久化操作
- Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久化操作的数据都缓存在 session 对象处
- 持久化类与 Session 关联起来后就具有了持久化的能力
2. 特点
- 不是线程安全的。应避免多个线程使用同一个Session实例，不要将session定义为全局变量，用的时候取一个session，用完销毁。
- Session是轻量级的，它的创建和销毁不会消耗太多的资源。应为每次客户请求分配独立的Session实例
- Session有一个缓存，被称之为Hibernate的一级缓存。每个Session实例都有自己的缓存
3. 常用的方法
- save(obj) ——添加数据
- delete(obj) ——删除数据
- get(Class,id)——根据主键查询一条数据
- update(obj) ——更新数据
- saveOrUpdate(obj) ——保存或者修改（如果没有数据，保存数据。如果有，修改数据）
- createQuery(String hql) —— 查询所有的数据，HQL语句的查询的方式
编写测试类（测试上述方法）
import java.util.List;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.feng.domain.Customer;
import com.feng.util.HibernateUtil;
public class TestSession {
Session session;
Transaction transaction;
@Before
public void init() {
session = HibernateUtil.openSession();
transaction = session.beginTransaction();
}
@Test
// get 获取一条记录
public void get() {
// 第一个参数是Javabean类，第二个参数是数据表的id值，3L为长整型
Customer customer = session.get(Customer.class, 3L);
System.out.println(customer);
}
@Test
// save
public void save() {
Customer customer = new Customer();
customer.setCust_name("肖战");
session.save(customer);
}
@Test
// update
public void update() {
Customer customer = session.get(Customer.class, 4L);
customer.setCust_name("新鲜的肖战");
session.update(customer);
}
@Test
// delete
public void delete() {
Customer customer = session.get(Customer.class, 2L);
session.delete(customer);
}
@Test
// createQuery
public void queryAll() {
// 1.执行createQuery方法返回query接口
// createQuery方法里写HQL语句，面向Javabean查询，hql不能出现表名，只能出现Javabean的名字
List<Customer> list = session.createQuery("from Customer").list();
for (Customer customer : list) {
System.out.println(customer);
}
}
@After
public void destory() {
transaction.commit();
session.close();
}
}
测试结果
get（Class,id）
save(obj)
update(obj)
delete(obj)
createQuery(String hql)
Transaction接口
1. Transaction是事务的接口
2. 常用的方法
- commit() ——提交事务
- rollback() ——回滚事务
3. 特点
- Hibernate框架默认情况下事务不自动提交.需要手动提交事务
- 如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务
事务代码编写
public class TestTransaction {
@Test
// 标准的事务操作，保存数据
public void save() {
Session session = null;
Transaction transaction = null;
try {
session = HibernateUtil.openSession();
transaction = session.beginTransaction();
Customer customer = new Customer();
customer.setCust_name("胡歌");
session.save(customer);
// 提交事务
transaction.commit();
} catch (Exception e) {
// TODO: handle exception
// 回滚
transaction.rollback();
} finally {
session.close();
}
}
}
测试结果
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
