在工程上点击右键弹出如下的菜单后进入如下的处理路径build Path->add External Arachives如下点击后弹出包选择窗口
选择如下窗口中的java包,将其导入到系统的处理路径中
导入包后的工程路径如下:
2.2 如何编写数据库层的orm。
2.2.1 编写数据库的创建脚本.
编写大致如下的数据库脚本,在数据库中执行后创建了test数据库和records,records2两个系统结构的表
DROP DATABASE IF EXISTS test;
CREATE DATABASE test DEFAULT CHARSET=utf8;
USE test;
DROP TABLE IF EXISTS `records`;
CREATE TABLE `records` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
`description` varchar(255) DEFAULT '',
`quantity` varchar(11) DEFAULT NULL,
`price` varchar(19) DEFAULT NULL,
`state` tinyint(1) DEFAULT '0',
`createTime` timestamp NULL DEFAULT '2005-01-12 12:23:59' ON UPDATE CURRENT_TIMESTAMP,
`length` bigint(16) DEFAULT NULL,
`sex2` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
DROP TABLE IF EXISTS `records2`;
CREATE TABLE `records2` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
`description` varchar(255) DEFAULT '',
`quantity` varchar(11) DEFAULT NULL,
`price` varchar(19) DEFAULT NULL,
`state` tinyint(1) DEFAULT '0',
`createTime` timestamp NULL DEFAULT '2005-01-12 12:23:59' ON UPDATE CURRENT_TIMESTAMP,
`length` bigint(16) DEFAULT NULL,
`sex2` varchar(20) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
2.2.2编写records和records2对应的数据封装类records类
编写records和records2对应的数据封装类records,该类将对两个数据表都具有有效的封装
2 package test.jdao;
3
4
5 import java.util.Date;
6
7 public class Records {
8
9 private int id=1;
10
11 private String name;
12
13 private String description;
14
15 private String quantity;
16
17 private String price;
18
19 private boolean state;
20
21 private Date createTime;
22
23 private long length;
24
25 private String sex;
26
27 public int getId() {
28 return id;
29 }
30
31 public void setId(int id) {
32 this.id = id;
33 }
34
35 public String getName() {
36 return name;
37 }
38
39 public void setName(String name) {
40 this.name = name;
41 }
42
43 public String getDescription() {
44 return description;
45 }
46
47 public void setDescription(String description) {
48 this.description = description;
49 }
50
51 public String getQuantity() {
52 return quantity;
53 }
54
55 public void setQuantity(String quantity) {
56 this.quantity = quantity;
57 }
58
59 public String getPrice() {
60 return price;
61 }
62
63 public void setPrice(String price) {
64 this.price = price;
65 }
66
67 public boolean getState() {
68 return state;
69 }
70
71 public void setState(boolean state) {
72 this.state = state;
73 }
74
75 public Date getCreateTime() {
76 return createTime;
77 }
78
79 public void setCreateTime(Date createTime) {
80 this.createTime = createTime;
81 }
82
83 public long getLength() {
84 return length;
85 }
86
87 public void setLength(long length) {
88 this.length = length;
89 }
90
91 public String getSex() {
92 return sex;
93 }
94
95 public void setSex(String sex) {
96 this.sex = sex;
97 }
98
99 }
2.2.3 编写record类的引导加载信息:
<?xml version="1.0"?>
<hibernate-mapping package="test.jdao">
<class name="Records" table="Records">
<id name="id" column="id" type="int">
<generator class="native" />
</id>
<property name="name" column="name" type="string" />
<property name="description" column="description" type="string" />
<property name="quantity" column="quantity" type="string" />
<property name="price" column="price" type="string" />
<property name="state" column="state" type="boolean" />
<property name="length" column="length" type="long" />
<property name="createTime" column="createTime" type="date" />
<property name="sex" column="sex2" type="string" />
<sqlaction>
<sqlitem actionName="emailaction">
<property name="name" column="name" type="string" />
<property name="description" column="description" type="string" />
<property name="quantity" column="quantity" type="string" />
</sqlitem>
<sqlitem actionName="state">
<property name="state" column="state" type="boolean" />
</sqlitem>
</sqlaction>
</class>
</hibernate-mapping>
2.2.4 继承AbstractJDAOImpl到实现对record类的处理。
package test.jdao;
import java.util.Date;
import net.jcore.core.JDAOTableDes;
import net.jcore.daofactory.AbstractJDAOImpl;
public class RecordsJDAO extends AbstractJDAOImpl<Records>{
/**
*使用泛型将records进行与核心进行连续
**/
public RecordsJDAO() {
super(Records.class);
}
/**
*实现对records类测工厂初始化方法,避免到处new 操作
**/
public Records initObject() {
Records records=new Records();
records.setId(0);
records.setName("name");
records.setDescription("description");
records.setQuantity("quantity");
records.setPrice("price");
records.setState(false);
records.setCreateTime(new Date());
records.setLength(12);
records.setSex("sex");
return records;
}
/**
* 继承获取表结构描述对像,该方法如果仅有一个表的时候是不需要重载的
其中的actionName为配置文件中的actionName,如果没有对应的actionName将返回一个表的全部结构类型,如果需要表的变换操作可以修改和处理jdaotabledes结构进行,比如如下的如果actionName的前缀为extend的话操作将变换到records2上进行,其他的都将在record表上进行
*/
public JDAOTableDes getJDAOTableDes(String actionName)throws Exception {
String prifor="base";//extend
if(actionName!=null){
int index=actionName.indexOf("#");
if(index>=0){
prifor=actionName.substring(0,index).toLowerCase();
actionName=actionName.substring(index+1);
}
}
/**
* 根据名称获取表结构对象
*/
JDAOTableDes jDAOTableDes =super.getJDAOTableDes(actionName);
if(prifor.equals("extend")){//如果是扩展表将表名称设置为records2
jDAOTableDes.setTable("records2");
}
return jDAOTableDes;
}
}
2.2.5 编写TestFactory类使用工厂
编写TestFactory类使用单例工厂模式进行表处理对象的管理如下
package test.factory;
import java.util.HashMap;
import java.util.Map;
import net.jcore.daofactory.AbstractJDAOImpl;
import test.jdao.RecordsJDAO;
public class TestFactory {
private static Map<String,AbstractJDAOImpl> daoMap=new HashMap<String,AbstractJDAOImpl>();
static{
daoMap.put("test", new RecordsJDAO());
}
public static RecordsJDAO getRecordsJDAO(){
return (RecordsJDAO)daoMap.get("test");
}
}
2.2.6 系统配置文件修改
将程序提供的配置文件hjdaoutilcore.xml,log4j.properties,jcore.properties拷贝到工程中,修改后的配置文件如下:
hjdaoutilcore.xml
<?xml version="1.0" ?>
<jcore>
<datasource type="c3p0" resource="configuration.properties" />
<dialect>net.jcore.dialect.MySQLDialect</dialect>
<tables debug="true">
<table resource="test/jdao/Records.hbm.xml" order="1"/>
</tables>
</jcore>
jcore.properties
#c3p0.properties start
datasource.breakAfterAcquireFailure=true
datasource.maxPoolSize=15
datasource.initialPoolSize=5
datasource.minPoolSize=6
datasource.acquireIncrement=2
datasource.jdbcUrl=jdbc:mysql://localhost:3306/soso?autoReconnect=true&useUnicode=true&characterEncoding=utf-8
datasource.username=root
datasource.maxIdleTime=60
datasource.maxStatements=40
datasource.acquireRetryDelay=10
datasource.acquireRetryAttempts=30
datasource.idleConnectionTestPeriod=60
datasource.driverClass=com.mysql.jdbc.Driver
datasource.password=
#c3p0.properties end@
log4j.properties
log4j.rootLogger=info,CONSOLE
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern= %4p [%t] (%F:%L) - %m%n
2.2.7 test 程序如何加载使用
按照如下的代码编写测试使用例子
package test;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import net.jcore.core.HJDAOCore;
import net.jcore.core.JCore;
import test.factory.TestFactory;
import test.jdao.Records;
import test.jdao.RecordsJDAO;
public class Test {
/**
* @param args
*/
public static void main(String[] args) throws Exception{
/**
* 让核心加载引导配置文件
*/
HJDAOCore.initCore("jCoreName", "hjdaoutilcore.xml");
//使用records表的处理jdao类
RecordsJDAO recordsJDAO=TestFactory.getRecordsJDAO();
//初始化一个对象
Records records=recordsJDAO.initObject();
/**
* 程序如何保持一个对象到record表中,其中id将自动赋值
*/
recordsJDAO.insert(records);
/**
* 程序如何保持一个对象到record2表中,其中id将自动赋值
*/
recordsJDAO.insert(records,"ddd");
/**
* 程序如何在一个事物中插入1000个record记录
* 并将record记录保存后跟新state字段
*/
JCore jCore = HJDAOCore.getJCore();
jCore.start();//首先开启计数
try{
jCore.beginTransaction();//开启事物
String name=records.getName();
for(int i=0;i<1000;i++){
records.setName(name+i);
/**
* 插入一个新的records字段,下面的操作将产生如下的sql
* sql:insert into Records(id,name,description,quantity,price,state,length,createTime,sex2) value(?,?,?,?,?,?,?,?,?)
*/
recordsJDAO.insert(records);//插入数据
}
jCore.endTransaction(); //结束事务
}catch(Exception ex){
ex.printStackTrace();
}finally{
jCore.end();//最后结束计数
}
/**
* 如何查询基表的数据,将数据从record拷贝到record2表中
* record2中将拥有record表中出id字段外的所有数据
*/
jCore.start();// 首先开启计数
try{
jCore.beginTransaction();//开启事物计数
Map<String,String> map=new LinkedHashMap<String,String>();
map.put("order by id asc", null);
/**
* 下面的操作将产生如下的sql语句
* select name,description,quantity,price,state,length,createTime,sex2 from Records where 1=1 order by id asc
*
*/
List<Records> list=recordsJDAO.findQuery(map);
for(int i=0;i<list.size();i++){
records=list.get(i);
/**
* 下面将产生如下的sql语句
* delete from Records where 1=1 and id=?
* 将id对应的记录从records表中删除
*/
recordsJDAO.delete(String.valueOf(records.getId()));
/**
* 下面将产生如下的sql语句
* insert into records2(id,name,description,quantity) value(?,?,?,?)
* 将records 对象的name,description,quantity属性插入record2表中,id将由主键生成器自动赋值生成
*/
recordsJDAO.insert(records,"emailaction");
}
jCore.endTransaction(); // 结束事务计数
}catch(Exception ex){
ex.printStackTrace();
}finally{
jCore.end();//关闭计数,结束事物
}
/**
* 如何测试扩散性事务的可靠性,执行完成上面的代码后,
* record将没有任何一条数据,record2将会有1000条数据
* 下面的代码将record表中插入10条数据后
* 复制拷贝前8条数据后抛出异常,结果为record表有10条数据,record表有1000数据
* 系统的扩散事务是可可靠的
*/
records=recordsJDAO.initObject();
for(int i=0;i<10;i++){
records.setName("name"+i);
/**
* 插入一个新的records字段,下面的操作将产生如下的sql
* sql:insert into Records(id,name,description,quantity,price,state,length,createTime,sex2) value(?,?,?,?,?,?,?,?,?)
*/
recordsJDAO.insert(records);//插入数据
}
jCore.start();// 首先开启计数
try{
jCore.beginTransaction();//开启事物计数
Map<String,String> map=new LinkedHashMap<String,String>();
map.put("order by id asc", null);
List<Records> list=recordsJDAO.findQuery(map);
for(int i=0;i<list.size();i++){
records=list.get(i);
recordsJDAO.delete(String.valueOf(records.getId()));
recordsJDAO.insert(records,"emailaction");
if(i==7){
throw new Exception("测试代码的扩散性事务!");
}
}
jCore.endTransaction(); // 结束事务计数
}catch(Exception ex){
ex.printStackTrace();
}finally{
jCore.end();//关闭计数,结束事物
}
}
}
2.2.8 程序使用注意事项:
1. 程序需要加载一次配置文件,执行 HJDAOCore.initCore("jCoreName", "hjdaoutilcore.xml");
2. orm继承的AbstractJDAOImpl的所以方法自动支持事务
3. jCore.start() 和 jCore.end() 需要成对使用,而且要确保一定要执行
4. jCore.beginTransaction()和jCore.endTransaction()事务要成对使用,如果执行过程中发生了一次异常,所有操作都将事务回滚。
5. JCore对象只能有JCore jCore = HJDAOCore.getJCore();获取,不能单独new 获得
2.2.9 程序最后的工程结构
如下图