2.1.2 导入工程需要的jar

在工程上点击右键弹出如下的菜单后进入如下的处理路径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 程序最后的工程结构

如下图