- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章详解Java的Hibernate框架中的缓存与原生SQL语句的使用由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.
Hibernate缓存 缓存是所有关于应用程序的性能优化和它位于应用程序和数据库之间,以避免数据库访问多次,让性能关键型应用程序有更好的表现.
缓存对Hibernate很重要,它采用了多级缓存方案下文所述:
第一级缓存: 第一级缓存是Session的缓存,是一个强制性的缓存,通过它所有的请求都必须通过。 Session对象不断自身的动力的对象,提交到数据库之前.
如果发出多个更新一个对象,Hibernate试图拖延尽可能长的时间做了更新,以减少发出的更新SQL语句的数量。如果您关闭会话,所有被缓存的对象都将丢失,要么持久,或在数据库中更新.
二级缓存: 二级缓存是可选的缓存和一级缓存,总是会征询任何试图找到一个对象的二级缓存之前。第二级缓存可以在每个类和每个集合基础上进行配置,主要负责在会话缓存的对象.
任何第三方缓存可以使用Hibernate。org.hibernate.cache.CacheProvider接口提供,必须实施提供Hibernate一个句柄缓存实现.
查询级别缓存: Hibernate也实现了查询结果集缓存与二级缓存的紧密集成在一起.
这是一个可选功能,需要两个额外的物理缓存中保存缓存的查询结果和地区当一个表的最后更新的时间戳。这只是针对那些使用相同的参数经常运行的查询非常有用.
二级缓存: Hibernate使用一级缓存,默认情况下,你什么都没有做使用第一级缓存。让我们直接进入可选的第二级缓存。并不是所有的类受益于缓存,这样一来就能禁用二级缓存是很重要的 。
Hibernate二级缓存被设置为两个步骤。首先,必须决定要使用的并发策略。在此之后,可以配置缓存过期和使用缓存提供物理缓存属性.
并发策略: 并发策略是一个中介的负责存储数据项在缓存并从缓存中检索它们。如果要启用二级缓存,将必须决定,为每个持久化类和集合,要使用的缓存并发策略.
Transactional: 使用这种策略的主要读取数据的地方,以防止过时的数据的并发事务,在更新的罕见情况下是至关重要的.
Read-write: 再次使用这种策略的主要读取数据的地方,以防止并发事务陈旧的数据是至关重要的,在更新的罕见情况.
Nonstrict-read-write: 这种策略不保证缓存与数据库之间的一致性。使用此策略,如果数据很少改变和陈旧数据的可能性很小关键是不关注.
Read-only: 并发策略适用于数据,永远不会改变。使用数据仅供参考.
如果我们要使用第二级缓存为我们的Employee类,让我们添加告诉Hibernate使用可读写的高速缓存策略Employee实例所需的映射元素.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<
hibernate-mapping
>
<
class
name
=
"Employee"
table
=
"EMPLOYEE"
>
<
meta
attribute
=
"class-description"
>
This class contains the employee detail.
</
meta
>
<
cache
usage
=
"read-write"
/>
<
id
name
=
"id"
type
=
"int"
column
=
"id"
>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"firstName"
column
=
"first_name"
type
=
"string"
/>
<
property
name
=
"lastName"
column
=
"last_name"
type
=
"string"
/>
<
property
name
=
"salary"
column
=
"salary"
type
=
"int"
/>
</
class
>
</
hibernate-mapping
>
|
usage="read-write" 属性告诉Hibernate使用一个可读写的并发策略定义的缓存.
缓存提供者: 考虑到会用你的缓存候选类的并发策略后,下一步就是选择一个缓存提供程序。Hibernate迫使选择一个缓存提供整个应用程序.
在指定hibernate.cfg.xml配置文件中的缓存提供。选择EHCache作为第二级缓存提供程序:
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
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<
hibernate-configuration
>
<
session-factory
>
<
property
name
=
"hibernate.dialect"
>
org.hibernate.dialect.MySQLDialect
</
property
>
<
property
name
=
"hibernate.connection.driver_class"
>
com.mysql.jdbc.Driver
</
property
>
<!-- Assume students is the database name -->
<
property
name
=
"hibernate.connection.url"
>
jdbc:mysql://localhost/test
</
property
>
<
property
name
=
"hibernate.connection.username"
>
root
</
property
>
<
property
name
=
"hibernate.connection.password"
>
root123
</
property
>
<
property
name
=
"hibernate.cache.provider_class"
>
org.hibernate.cache.EhCacheProvider
</
property
>
<!-- List of XML mapping files -->
<
mapping
resource
=
"Employee.hbm.xml"
/>
</
session-factory
>
</
hibernate-configuration
>
|
现在,需要指定缓存区域的属性。EHCache都有自己的配置文件ehcache.xml,在应用程序在CLASSPATH中。在ehcache.xml中Employee类高速缓存配置可能看起来像这样:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
<
diskStore
path
=
"java.io.tmpdir"
/>
<
defaultCache
maxElementsInMemory
=
"1000"
eternal
=
"false"
timeToIdleSeconds
=
"120"
timeToLiveSeconds
=
"120"
overflowToDisk
=
"true"
/>
<
cache
name
=
"Employee"
maxElementsInMemory
=
"500"
eternal
=
"true"
timeToIdleSeconds
=
"0"
timeToLiveSeconds
=
"0"
overflowToDisk
=
"false"
/>
|
就这样,现在启用Employee类的二级缓存和Hibernate现在二级缓存,每当浏览到一个雇员或当通过标识符加载雇员.
应该分析你所有的类,并选择适当的缓存策略为每个类。有时,二级缓存可能降级的应用程序的性能。所以建议到基准应用程序第一次没有启用缓存,非常适合缓存和检查性能。如果缓存不提高系统性能再有就是在使任何类型的缓存是没有意义的.
查询级别缓存: 使用查询缓存,必须先使用 hibernate.cache.use_query_cache="true"属性配置文件中激活它。如果将此属性设置为true,让Hibernate的在内存中创建所需的高速缓存来保存查询和标识符集.
接下来,使用查询缓存,可以使用Query类的setCacheable(Boolean)方法。例如:
1
2
3
4
5
|
Session session = SessionFactory.openSession();
Query query = session.createQuery(
"FROM EMPLOYEE"
);
query.setCacheable(
true
);
List users = query.list();
SessionFactory.closeSession();
|
Hibernate也支持通过一个缓存区域的概念非常细粒度的缓存支持。缓存区是这是给定一个名称缓存的一部分.
1
2
3
4
5
6
|
Session session = SessionFactory.openSession();
Query query = session.createQuery(
"FROM EMPLOYEE"
);
query.setCacheable(
true
);
query.setCacheRegion(
"employee"
);
List users = query.list();
SessionFactory.closeSession();
|
此代码使用方法告诉Hibernate来存储和查找在缓存中的员工方面的查询.
Hibernate原生SQL 可以使用原生SQL来表达数据库查询,如果想利用数据库特有的功能,如查询提示或者Oracle中的CONNECT关键字。 Hibernate3.x允许使用手写SQL语句,包括存储过程,所有的创建,更新,删除和load操作.
应用程序将从会话创建一个原生SQL查询(Session接口上)createSQLQuery()方法:
public SQLQuery createSQLQuery(String sqlString) throws HibernateException 当传递一个包含SQL查询到createSQLQuery()方法,可以将SQL结果与任何现有的Hibernate实体,联接,或者一个标量结果使用addEntity()方法,addJoin(),和addScalar()方法关联的字符串.
标量查询: 最基本的SQL查询是从一个或多个表中得到标量(数值)的列表。以下是语法使用原生SQL标量的值:
1
2
3
4
|
String sql =
"SELECT first_name, salary FROM EMPLOYEE"
;
SQLQuery query = session.createSQLQuery(sql);
query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
List results = query.list();
|
实体的查询: 上面的查询都是返回标量值,也就是从resultset中返回的“裸”数据。以下是语法通过addEntity()方法来从原生SQL查询获得实体对象作为一个整体.
1
2
3
4
|
String sql =
"SELECT * FROM EMPLOYEE"
;
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Employee.
class
);
List results = query.list();
|
命名SQL查询: 以下是语法通过addEntity()方法来从原生SQL查询获得实体对象和使用命名SQL查询.
1
2
3
4
5
|
String sql =
"SELECT * FROM EMPLOYEE WHERE id = :employee_id"
;
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Employee.
class
);
query.setParameter(
"employee_id"
,
10
);
List results = query.list();
|
Native SQL 例子: 考虑下面的POJO类:
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
|
public
class
Employee {
private
int
id;
private
String firstName;
private
String lastName;
private
int
salary;
public
Employee() {}
public
Employee(String fname, String lname,
int
salary) {
this
.firstName = fname;
this
.lastName = lname;
this
.salary = salary;
}
public
int
getId() {
return
id;
}
public
void
setId(
int
id ) {
this
.id = id;
}
public
String getFirstName() {
return
firstName;
}
public
void
setFirstName( String first_name ) {
this
.firstName = first_name;
}
public
String getLastName() {
return
lastName;
}
public
void
setLastName( String last_name ) {
this
.lastName = last_name;
}
public
int
getSalary() {
return
salary;
}
public
void
setSalary(
int
salary ) {
this
.salary = salary;
}
}
|
让我们创建下面的EMPLOYEE表来存储Employee对象:
1
2
3
4
5
6
7
|
create
table
EMPLOYEE (
id
INT
NOT
NULL
auto_increment,
first_name
VARCHAR
(20)
default
NULL
,
last_name
VARCHAR
(20)
default
NULL
,
salary
INT
default
NULL
,
PRIMARY
KEY
(id)
);
|
以下将被映射文件.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<
hibernate-mapping
>
<
class
name
=
"Employee"
table
=
"EMPLOYEE"
>
<
meta
attribute
=
"class-description"
>
This class contains the employee detail.
</
meta
>
<
id
name
=
"id"
type
=
"int"
column
=
"id"
>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"firstName"
column
=
"first_name"
type
=
"string"
/>
<
property
name
=
"lastName"
column
=
"last_name"
type
=
"string"
/>
<
property
name
=
"salary"
column
=
"salary"
type
=
"int"
/>
</
class
>
</
hibernate-mapping
>
|
最后,我们将创建应用程序类的main()方法来运行,我们将使用原生SQL查询的应用程序:
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
98
99
100
101
102
103
104
105
106
|
import
java.util.*;
import
org.hibernate.HibernateException;
import
org.hibernate.Session;
import
org.hibernate.Transaction;
import
org.hibernate.SessionFactory;
import
org.hibernate.SQLQuery;
import
org.hibernate.Criteria;
import
org.hibernate.Hibernate;
import
org.hibernate.cfg.Configuration;
public
class
ManageEmployee {
private
static
SessionFactory factory;
public
static
void
main(String[] args) {
try
{
factory =
new
Configuration().configure().buildSessionFactory();
}
catch
(Throwable ex) {
System.err.println(
"Failed to create sessionFactory object."
+ ex);
throw
new
ExceptionInInitializerError(ex);
}
ManageEmployee ME =
new
ManageEmployee();
/* Add few employee records in database */
Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
Integer empID3 = ME.addEmployee("John", "Paul", 5000);
Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);
/* List down employees and their salary using Scalar Query */
ME.listEmployeesScalar();
/* List down complete employees information using Entity Query */
ME.listEmployeesEntity();
}
/* Method to CREATE an employee in the database */
public Integer addEmployee(String fname, String lname, int salary){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try{
tx = session.beginTransaction();
Employee employee = new Employee(fname, lname, salary);
employeeID = (Integer) session.save(employee);
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
return employeeID;
}
/* Method to READ all the employees using Scalar Query */
public void listEmployeesScalar( ){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
String sql = "SELECT first_name, salary FROM EMPLOYEE";
SQLQuery query = session.createSQLQuery(sql);
query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
List data = query.list();
for(Object object : data)
{
Map row = (Map)object;
System.out.print("First Name: " + row.get("first_name"));
System.out.println(", Salary: " + row.get("salary"));
}
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
/* Method to READ all the employees using Entity Query */
public
void
listEmployeesEntity( ){
Session session = factory.openSession();
Transaction tx =
null
;
try
{
tx = session.beginTransaction();
String sql =
"SELECT * FROM EMPLOYEE"
;
SQLQuery query = session.createSQLQuery(sql);
query.addEntity(Employee.
class
);
List employees = query.list();
for
(Iterator iterator =
employees.iterator(); iterator.hasNext();){
Employee employee = (Employee) iterator.next();
System.out.print(
"First Name: "
+ employee.getFirstName());
System.out.print(
" Last Name: "
+ employee.getLastName());
System.out.println(
" Salary: "
+ employee.getSalary());
}
tx.commit();
}
catch
(HibernateException e) {
if
(tx!=
null
) tx.rollback();
e.printStackTrace();
}
finally
{
session.close();
}
}
}
|
编译和执行: 下面是步骤来编译并运行上述应用程序。请确保在进行的编译和执行之前,适当地设置PATH和CLASSPATH.
执行ManageEmployee二进制文件来运行程序.
会得到以下结果,并记录将在EMPLOYEE表中创建.
1
|
$java ManageEmployee
|
1
2
3
4
5
6
7
8
9
10
|
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
First Name: Zara, Salary: 2000
First Name: Daisy, Salary: 5000
First Name: John, Salary: 5000
First Name: Mohd, Salary: 3000
First Name: Zara Last Name: Ali Salary: 2000
First Name: Daisy Last Name: Das Salary: 5000
First Name: John Last Name: Paul Salary: 5000
First Name: Mohd Last Name: Yasee Salary: 3000
|
如果检查EMPLOYEE表,它应该记录下已:
1
|
mysql>
select
*
from
EMPLOYEE;
|
1
2
3
4
5
6
7
8
9
|
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 26 | Zara | Ali | 2000 |
| 27 | Daisy | Das | 5000 |
| 28 | John | Paul | 5000 |
| 29 | Mohd | Yasee | 3000 |
+----+------------+-----------+--------+
4 rows in set (0.00 sec)
|
。
最后此篇关于详解Java的Hibernate框架中的缓存与原生SQL语句的使用的文章就讲到这里了,如果你想了解更多关于详解Java的Hibernate框架中的缓存与原生SQL语句的使用的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我想做的是让 JTextPane 在 JPanel 中占用尽可能多的空间。对于我使用的 UpdateInfoPanel: public class UpdateInfoPanel extends JP
我在 JPanel 中有一个 JTextArea,我想将其与 JScrollPane 一起使用。我正在使用 GridBagLayout。当我运行它时,框架似乎为 JScrollPane 腾出了空间,但
我想在 xcode 中实现以下功能。 我有一个 View Controller 。在这个 UIViewController 中,我有一个 UITabBar。它们下面是一个 UIView。将 UITab
有谁知道Firebird 2.5有没有类似于SQL中“STUFF”函数的功能? 我有一个包含父用户记录的表,另一个表包含与父相关的子用户记录。我希望能够提取用户拥有的“ROLES”的逗号分隔字符串,而
我想使用 JSON 作为 mirth channel 的输入和输出,例如详细信息保存在数据库中或创建 HL7 消息。 简而言之,输入为 JSON 解析它并输出为任何格式。 最佳答案 var objec
通常我会使用 R 并执行 merge.by,但这个文件似乎太大了,部门中的任何一台计算机都无法处理它! (任何从事遗传学工作的人的附加信息)本质上,插补似乎删除了 snp ID 的 rs 数字,我只剩
我有一个以前可能被问过的问题,但我很难找到正确的描述。我希望有人能帮助我。 在下面的代码中,我设置了varprice,我想添加javascript变量accu_id以通过rails在我的数据库中查找记
我有一个简单的 SVG 文件,在 Firefox 中可以正常查看 - 它的一些包装文本使用 foreignObject 包含一些 HTML - 文本包装在 div 中:
所以我正在为学校编写一个 Ruby 程序,如果某个值是 1 或 3,则将 bool 值更改为 true,如果是 0 或 2,则更改为 false。由于我有 Java 背景,所以我认为这段代码应该有效:
我做了什么: 我在这些账户之间创建了 VPC 对等连接 互联网网关也连接到每个 VPC 还配置了路由表(以允许来自双方的流量) 情况1: 当这两个 VPC 在同一个账户中时,我成功测试了从另一个 La
我有一个名为 contacts 的表: user_id contact_id 10294 10295 10294 10293 10293 10294 102
我正在使用 Magento 中的新模板。为避免重复代码,我想为每个产品预览使用相同的子模板。 特别是我做了这样一个展示: $products = Mage::getModel('catalog/pro
“for”是否总是检查协议(protocol)中定义的每个函数中第一个参数的类型? 编辑(改写): 当协议(protocol)方法只有一个参数时,根据该单个参数的类型(直接或任意)找到实现。当协议(p
我想从我的 PHP 代码中调用 JavaScript 函数。我通过使用以下方法实现了这一点: echo ' drawChart($id); '; 这工作正常,但我想从我的 PHP 代码中获取数据,我使
这个问题已经有答案了: Event binding on dynamically created elements? (23 个回答) 已关闭 5 年前。 我有一个动态表单,我想在其中附加一些其他 h
我正在尝试找到一种解决方案,以在 componentDidMount 中的映射项上使用 setState。 我正在使用 GraphQL连同 Gatsby返回许多 data 项目,但要求在特定的 pat
我在 ScrollView 中有一个 View 。只要用户按住该 View ,我想每 80 毫秒调用一次方法。这是我已经实现的: final Runnable vibrate = new Runnab
我用 jni 开发了一个 android 应用程序。我在 GetStringUTFChars 的 dvmDecodeIndirectRef 中得到了一个 dvmabort。我只中止了一次。 为什么会这
当我到达我的 Activity 时,我调用 FragmentPagerAdapter 来处理我的不同选项卡。在我的一个选项卡中,我想显示一个 RecyclerView,但他从未出现过,有了断点,我看到
当我按下 Activity 中的按钮时,会弹出一个 DialogFragment。在对话框 fragment 中,有一个看起来像普通 ListView 的 RecyclerView。 我想要的行为是当
我是一名优秀的程序员,十分优秀!