Dojo Month session 4 - New Build System In Dojo 1_7

合集下载

对基于Hibernate框架的数据访问组件进行单元测试的应用实例(JBuilder开发工具中实现)

1.1对基于Hibernate框架的数据访问组件进行单元测试的应用实例（JBuilder开发工具中实现）1、测试要点（1）对Hibernate组件的测试主要涉及如下两个方面的测试1)对其hibernate.cfg.xml文件以及各个O/R Mapping 的*.xml文件2)基于hibernate的DAO组件中的各个数据访问功能的方法进行测试。

（2）在测试用例类中利用Configuration类中的configure()方法来定位被测试系统的hibernate.cfg.xml文件，从而获得SessionFactory，最后获得Session。

2、测试用例的基本模板程序package examplestest;import org.hibernate.SessionFactory;import org.hibernate.Session;import java.io.File;import org.hibernate.cfg.Configuration;import junit.framework.TestCase;public class TestHibernate extends TestCase{private SessionFactory sessionFactory;private Session session;private List list;protected void setUp() throws Exception{ //创建出sessionFactorysuper.setUp();//根据实际改变File file = new File("C:\\temp\\J2SEApp\\classes\\hibernate.cfg.xml");Configuration config = new Configuration().configure(file);sessionFactory = config.buildSessionFactory();session = sessionFactory.openSession();}protected void tearDown() throws Exception{super.tearDown();}public void testSave() {}public void testQuery() {}}3、测试实例-------对应用项目中的“hibernate.cfg.xml文件以及各个O/R Mapping 的*.xml 文件”进行测试（1）以“在J2SE的应用程序中使用Hibernate技术（MSSQL）”一文中的程序作为测试的目标类（2）添加测试用例类输入包名称为examplestest，类名称为TestHibernateXML，基类为junit.framework.TestCase选择测试运行器为JBuilder Test Runner最后将产生出下面的代码package examplestest;import junit.framework.*;public class TestHibernateXML extends TestCase{protected void setUp() throws Exception {super.setUp();}protected void tearDown() throws Exception {super.tearDown();}}（3）编程该程序以实现对“hibernate.cfg.xml文件以及各个O/R Mapping 的*.xml文件”中各个配置项目进行测试，其代码如下package examplestest;import junit.framework.*;import org.hibernate.cfg.*;import org.hibernate.*;import java.io.File;public class TestHibernateXML extends TestCase{private SessionFactory sessionFactory=null;protected void setUp() throws Exception{super.setUp();//根据实际改变File file = new File("D:/HibernateExmp/J2SEApp/classes/hibernate.cfg.xml");Configuration config = new Configuration().configure(file);sessionFactory = config.buildSessionFactory();}public void testHibernateXML(){ //对hibernate.cfg.xml中各个配置项目进行测试this.assertNotNull(sessionFactory);}protected void tearDown() throws Exception{sessionFactory=null;super.tearDown();}}（4）执行该程序将产生下面的结果同时可以观察其状态输出（5）故意将Hibernate.cfg.xml中的配置项目设置错误比如：<property name="dialect">org.hibernate.dialect.SQLServerDialect1234</property>再执行该TestCase。

Dojo日期控件的国际化和集成

Dojo日期控件的国际化和集成Dojo 控件介绍Dojo 日期控件类型Dojo 目前支持两种日期控件：图1. dijit.form.TimeTextBox该类型控件为时间控件, 图中显示格式为:hh:mm:ss，该控件支持国际化, 其格式会根据国家的不同而相应变化。

图2.dijit.form.DateTextBox该类型控件为日期控件, 图中显示格式为:yyyy-MM-dd，该控件也支持国际化。

Dojo 日期控件的类层次结构图3. Dojo 日期控件类结构图图3 列出了Dojo 日期控件所依赖的主要组件，下面分别介绍它们的功能：dijit.form._ FormiWidget所有dijit 控件的基类，定义了Dojo 控件的一些共有特征，如id,name 属性，onFocus,onChange 事件等。

dijit.form.TextBox普通html 文本框的一个封装。

dijit.form.ValidationTextBox 提供验证功能的文本框, 子类可重写isValid() 方法来自定义验证规则。

dijit.form.MappedTextBox提供了一个和文本框对应的隐藏域，用于存放dojo 内部处理的结果, 并提供了一个方法serialize 来在内部值和显示值之间转化。

dijit.form.RangeBoundTextBox可定义取值范围的控件，并提供一个接口isInRange 来判断是否在给定范围内。

Dojo 日期控件的初始化Dojo 提供了两种初始化控件的途径：声明方式和编程方式。

声明方式通过给html 控件添加dojoType 属性，其值为dojo 控件的类名，在加载页面的过程中Dojo 会将指定了dojoType 的控件转为dojo 控件，如。

在页面加载完成后会转变为一个dojo 时间控件。

Dojo 是如何把普通的html控件转换为dojo 控件的呢？dojo.parser 在其中起了主要的作用。

java生成达梦数据库建表语句

一、介绍在现代软件开发中，数据库是必不可少的一部分，而创建数据库表是数据库设计的重要环节之一。

在使用Java语言开发软件的过程中，我们常常会使用到达梦数据库作为后台数据库。

本文将从Java语言生成达梦数据库建表语句展开讨论。

二、Java生成达梦数据库建表语句的方式1. 使用JDBCJava Database Connectivity（JDBC）是Java语言中用于与数据库进行交互的API。

通过JDBC，我们可以使用Java代码连接并操作数据库。

在使用JDBC生成达梦数据库建表语句时，我们可以通过以下步骤实现：1）导入数据库驱动2）建立数据库连接3）创建Statement对象4）执行SQL语句5）关闭数据库连接通过以上步骤，我们可以在Java中调用达梦数据库的API，生成数据库建表语句。

2. 使用ORM框架ORM（Object-Relational Mapping）是一种编程技术，它允许我们在Java中以面向对象的方式操作数据库。

在使用ORM框架生成达梦数据库建表语句时，我们可以通过以下步骤实现：1）选择合适的ORM框架，如Hibernate、MyBatis等2）创建实体类（Entity）3）配置映射关系4）进行数据库操作通过ORM框架，我们可以将Java中的实体类映射到达梦数据库中的表，从而生成数据库建表语句。

三、Java生成达梦数据库建表语句的示例代码以下是使用JDBC和ORM框架分别生成达梦数据库建表语句的示例代码：1. 使用JDBC```javaimport java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.Statement;public class CreateDmTableWithJDBC {public static void main(String[] args) {String url = "jdbc:damm://localhost:5236/demo";String user = "username";String password = "password";String sql = "CREATE TABLE employee " +"(id INTEGER not NULL, " +" name VARCHAR(255), " +" age INTEGER, " +" PRIMARY KEY ( id ))";try (Connection conn = DriverManager.getConnection(url, user, password);Statement stmt = conn.createStatement()) {stmt.execute(sql);System.out.println("Table created successfully");} catch (SQLException e) {System.out.println(e.getMessage());}}}```2. 使用ORM框架（以Hibernate为例）```javaimport org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;import.example.Employee;public class CreateDmTableWithHibernate {public static void main(String[] args) {Configuration config = newConfiguration().configure().addAnnotatedClass(Employee.class); SessionFactory sessionFactory =config.buildSessionFactory();Session session = sessionFactory.openSession();session.beginTransaction();session.getTransaction()mit();session.close();sessionFactory.close();}}```四、总结通过本文我们可以了解到，在Java语言中生成达梦数据库建表语句有多种方式，包括使用JDBC和ORM框架。

Eclipse下Hibernate入门

最近boss让做项目，借机学习了一下Hibernate，小有收获。

hiberante是对数据库持久层访问的一种机制，hibernate的应用可以使程序员将重点放到业务逻辑的实现上。

hibernate的原理是将数据库结构封装，使程序员可以像使用普通对象一样调用数据库的相关接口，从实现数据库的相关操作。

由于Exadel基于eclipse集成了Hibernate，并且方便易用所以我选用Exadel+Mysql还需要hibernate3.jar mysql-connector /downloads/在Mysql中新建test数据库（Mysql其实有个空的test数据库），然后新建下面的Tablecreate table user (id int(10) not null auto_increment primary key,name varchar(20) not null,password varchar(20) not null,email varchar(50),address varchar(100))type=innodb;新建Java Project，将Mysql_Driver,Hibernate两个user library添加到该工程的java build path中。

新建与数据表对应的POJO类：User和Contact/*****/package er;/*** @author lzy**/public class User{private Integer id;private String name;private String password;private Contact contact;/*** @return Returns the id.*/public Integer getId() {return id;}/*** @param id The id to set.*/public void setId(Integer id) { this.id = id;}/*** @return Returns the name.*/public String getName() {return name;}/*** @param name The name to set.*/public void setName(String name) { = name;}/*** @return Returns the password.*/public String getPassword() {return password;}/*** @param password The password to set.*/public void setPassword(String password) { this.password = password;}/*** @return Returns the contact.*/public Contact getContact() {return contact;}/*** @param contact The contact to set.*/public void setContact(Contact contact) { this.contact = contact;}}/****/package er;/*** @author lzy**/public class Contact {private String email;private String address;/*** @return Returns the address.*/public String getAddress() {return address;}/*** @param address The address to set.*/public void setAddress(String address) { this.address = address;}/*** @return Returns the email.*/public String getEmail() {return email;}/*** @param email The email to set.*/public void setEmail(String email) {this.email = email;}}添加Hibernate支持，这时系统会要求输入一些信息，按提示即可完成后系统自动生成hibernate.cfg.xml，User.hbm.xml映射文件必须稍作修改。

hibernate4学习笔记

hibernate4学习笔记Hibernate4学习笔记本⼈全部以⾃学为主，在⽹上收集各种学习资料，总结归纳学习经验，现将学习路径给予⼤家分享。

此次学习的hibernate的版本是：hibernate-release-4.2.4.Final（截⽌2015年7⽉31⽇最新版），JAVA的版本是：java8.0，使⽤的开发⼯具是：Eclipse Mars Release (4.5.0)。

第⼀天：Hibernate4基础知识和HelloWorld简单编程Hibernate是⼀种半成品ORM框架，对数据库持久化操作，程序员对数据库的操作转换成对对象的操作。

ORM 采⽤元数据来描述对象-关系映射细节, 元数据通常采⽤XML 格式, 并且存放在专门的对象-关系映射⽂件中。

HelloWorld简单编程1、准备Hibernate环境（1）导⼊Hibernate的Jar包，如下：（2）导⼊Mysql驱动包，我⽤的数据库是：Mysql 5.0，数据库驱动包如下：以上所有Jar加完毕之后，需要加⼊到Eclipse⾃⾝系统⾥⾯，具体如下：以上操作完毕之后，Hibernate的环境就算搭建完毕，下⾯就可以进⼀步操作。

2、配置hibernate.cfg.xml⽂件，主要是对数据库的连接，具体如下："-//Hibernate/Hibernate Configuration DTD 3.0//EN""/doc/63fa364d5022aaea998f0fde.html /hibernate-configuration-3.0.dtd ">rootmysqlname="connection.driver_class">com.mysql.jdbc.Driver jdbc:mysql:///Test(或者：jdbc:mysql://localhost:3306/Test)name="dialect">org.hibernate.dialect.MySQLInnoDBDialecttruetrueupdate3、编写⼀个实例类News.java，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) { super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridereturn"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射⽂件，具体代码如下："/doc/63fa364d5022aaea998f0fde.html /hibernate-mapping-3.0.dtd">5、将映射⽂件News.hbm.xml指定到hibernate.cfg.xml配置⽂件⾥⾯，即在hibernate.cfg.xml⽂件⾥加⼊⼀⾏映射代码，具体如下：6、创建hibernate API操作测试类（Juit测试），验证hibernate的优势效果，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.Test;public class HibernateTest {@Testpublic void test() {//1. 创建⼀个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建⼀个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建⼀个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执⾏保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务/doc/63fa364d5022aaea998f0fde.html mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下：（1）数据库⾥⾯的结果如下：（2）Eclipse下的语句⽣成如下：以上就是简单Hibernate的测试，总结：1、不需要在数据库⾥⾯创建任何数据，由hibernate ⾃动⽣成；2、代码简单易理解，不复杂，测试数据只需要先创建以下⼏个步骤：SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭；3、不需要写SQL 语句，从头到尾没有写⼀条SQL语句，反⽽Hibernate帮我们⽣成SQL语句。

java学习经验Hibernate总结

Hibernate工作原理及为什么要用？一原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory3.打开Sesssion4.创建事务Transaction5.持久化操作6.提交事务7.关闭Session。

8.关闭SessionFactory为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。

他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

4. hibernate的性能非常好，因为它是个轻量级框架。

映射的灵活性很出色。

它支持各种关系数据库，从一对一到多对多的各种复杂关系。

二Hibernate 的核心接口及其作用1 Configuration类：配置Hibernate启动Hibernate创建SessionFactory对象2 SessionFactory：初始化Hibernate创建Session对象线程安全—同一实例被多个线程共享重量级：代表一个数据库内部维护一个连接池2.1 openSession():总是创建新的session,需要手动close()2.2 getCurrentSession() : 必须在hibernate.cfg.xml设置session 上下文事务自动提交并且自动关闭session.从上下文环境中获得session,如果当时环境中不存就创建新的.如果环境中存在就使用环境中的,而且每次得到的都是同一个session (在session提交之前,提交之后就是新的了) 应用在一个session中有多个不同DAO操作处于一个事务时3 Session：负责保存、更新、删除、加载和查询对象轻量级－－可以经常创建或销毁3.1 Load与get方法的区别：简单理解：load是懒加载，get是立即加载.load方法当使用查出来的对象时并且session未关闭，才会向数据库发sql， get会立即向数据库发sql返回对象3.3 merge(); 合并对象更新前会先select 再更新3.4clear()清空缓存,flush()将session中的数据同步到数据库两者组合使用于批量数据处理3.4Transaction commit() rollback()JPA： java persistence API 提供了一组操作实体bean的注解和API规范SchemaExporthiberante的生成数据库表(及其他ddl)的工具类可以通过这个工具类完成一些ddl四Hibernate查询查询语言主要有:HQL 、QBC (Query By Criteria条件查询) 、 Native SQLHql：1、属性查询2、参数查询、命名参数查询3、关联查询4、分页查询5、统计函数五优化抓取策略连接抓取（Join fetching）使用 OUTER JOIN（外连接）来获得对象的关联实例或者关联集合查询抓取（Select fetching）另外发送一条 SELECT 语句抓取当前对象的关联实体或集合另外可以配置hibernate抓取数量限制批量抓取（Batch fetching）另外可以通过集合过滤来限制集合中的数据量使用session.createFilter(topic.getReplies(),queryString).list();检索策略延迟检索和立即检索（优先考虑延迟检索）N+1问题指hibernate在查询当前对象时查询相关联的对象查询一端时会查询关联的多端集合对象解决方案:延迟加载连接抓取策略二级缓存集合过滤 BatchSize限制记录数量映射建议使用双向一对多关联，不使用单向一对多灵活使用单向一对多关联不用一对一，用多对一取代配置对象缓存，不使用集合缓存一对多集合使用Bag,多对多集合使用Set继承类使用显式多态表字段要少，表关联不要怕多，有二级缓存撑腰Hibernbate缓存机制性能提升的主要手段Hibernate进行查询时总是先在缓存中进行查询,如缓存中没有所需数据才进行数据库的查询.Hibernbate缓存:一级缓存 (Session级别)二级缓存(SessionFactory级别)查询缓存 (基于二级缓存存储相同参数的sql查询结果集)一级缓存（session缓存）Session缓存可以理解为session中的一个map成员， key为OID ,value为持久化对象的引用在session关闭前，如果要获取记录，hiberntae先在session缓存中查找，找到后直接返回，缓存中没有才向数据库发送sql三种状态的区别在于:对象在内存、数据库、session缓存三者中是否有OID临时状态内存中的对象没有OID, 缓存中没有OID，数据库中也没有OID 执行new或delete()后持久化状态内存中的对象有OID, 缓存中有OID，数据库中有OIDsave() load() get() update() saveOrUpdate() Query对象返回的集合游离（脱管）状态内存中的对象有OID, 缓存中没有OID，数据库中可能有OIDflush() close()后使用session缓存涉及三个操作:1将数据放入缓存2从缓存中获取数据3缓存的数据清理4二级缓存SessionFactory级别SessionFactory级别的缓存,它允许多个Session间共享缓存一般需要使用第三方的缓存组件，如: Ehcache Oscache、JbossCache等二级缓存的工作原理:在执行各种条件查询时，如果所获得的结果集为实体对象的集合，那么就会把所有的数据对象根据OID放入到二级缓存中。

ASP 使用Dojo事件

ASP 使用Dojo事件一般情况下，Ajax事件处理方式都是：通过鼠标或者键盘触发HTML标记所具有的事件，浏览器调用相应的事件处理者处理事件（JavaScript函数），JavaScript方式很简单，但是存在不好的地方。

因为所有的HTML标记（例如<button>标签）会和事件处理（onclick=foo();）关联起来。

当该标记关联的事件比较少的时候，这个缺点体现不出来，但是当标记具有多个事件要触发，就会经常需要调整JavaScri pt方法和HTML标记时候就会暴露出来修改比较困难的问题。

Dojo框架没有采用这种方式进行事件处理，而是采用了一个connect方法，将HTML标记（事件源）和JavaScript函数（事件处理者）二者连接起来。

其代码如表示将firstButton的onclick事件和foo方法联系起来，当firstButton被单击的时候会触发foo方法。

这里就解决了页面标记（例如<button>标签）和事件处理之间关联的问题。

可以在onLoad方法内部将所有的关联链接起来。

addOnload()是dojo的一个方法，表示可以加载指定函数到window.load时执行，方法byId()是一个非常有用的一个方法，与prototype.js的著名的$一样，似乎以前的版本还有dojo.byIdArray，不过最新的版本已经找不到这个函数了(除了src\c ompat\0.2.2.js)。

该方法表示获取指定id的层的对象。

如果有多个元素具有指定的i事件的详细信息，就可以利用Dojo框架的Event Object对象。

其中，属性event.ch arCode表示针对于keypress事件表示ASCII值，event.target表示触发事件的HTML 元素。

现在创建一个案例，演示一下Dojo框架的事件处理。

打开记事本，输入下列代码：将上述代码保存，名称为Event.jsp。

ASP 配置Dojo框架

ASP 配置Dojo框架通过上一节的学习，了解到在Dojo框架中封装了一些标记，这些标记也可以独立使用，也可以作为HTML标记的扩展。

本节，根据上一节的学习，演示创建H TML页面的过程。

创建一个Dojo框架的HTML页面，其步骤如下：1．引入并配置Dojo由于dojo是由JavaScript编写，所以第一步必须首先引用dojo框架的JavaScri表示获取当前页面所在位置。

djConfig是Dojo追加的自定义属性，在HTML标准里并没有。

使用djConfig 可以做一些基本的配置，isDebug表示了当前页面中使用的dojo内容是否处在调试状态，在调试状态可以输出更多的内容，一般开发的时候选择true。

parseOnLoad 表示所有的dijit组件是否在html页面装载的时候自动的做展现（Render）处理，使用dijit组件的时候选择true，没有使用的时候使用false可以获得更好的性能。

2．引入Dojo类引用需要使用的dojo类，这一步有些像Java中的import，注意添加引用的类会增加页面加载是JavaScript的下载量，所以应该尽量的精简引用的dojo对象。

代码为：上述的代码说明了在后续的代码中可能使用的dojo组件，如果要使用其他组件也可以以相同方式引入。

在引入这些组件时，需要注意组件所在路径。

3．引用CSS文件引用需要使用的CSS文件，由于dojo使用CSS实现了主题的概念，所以在使当然，也可以加入自己的内容，自定以主题。

默认的主题时tundra主题。

另外4．使用dijit组件所有的组件都有一个dojo自定义的属性dojoType，dojoType决定了这个组件的dijit类型。

在上述代码中，首先引入dojo.js文件，并对于config进行配置。

在脚本程序中，语句dojo.require("dijit.form.DateTextbox")等表示包含要使用的dijit组件，如dijit.form.DateTextbox。

Hibernate4在开发当中的一些改变

Hibernate4的改动较大只有spring3.1以上版本能够支持，Spring3.1取消了HibernateTemplate，因为Hibernate4的事务管理已经很好了，不用Spring再扩展了。

这里简单介绍了hibernate4相对于hibernate3配置时出现的错误，只列举了问题和解决方法，详细原理如果大家感兴趣还是去自己搜吧，网上很多。

1. Spring3.1去掉了HibernateDaoSupport类。

hibernate4需要通过getCurrentSession()获取session。

并且设置<propkey="hibernate.current_session_context_class">org.springframework.orm.hibe rnate4.SpringSessionContext</prop>（在hibernate3的时候是thread和jta）。

2. 缓存设置改为<propkey="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvi der</prop><propkey="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhC acheRegionFactory</prop>3. Spring对hibernate的事务管理，不论是注解方式还是配置文件方式统一改为：<bean id="txManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager" ><property name="sessionFactory"><ref bean="sessionFactory"/></property></bean>4. getCurrentSession()事务会自动关闭，所以在有所jsp页面查询数据都会关闭session。

java写入mongo double类型的数据是科学计数法-概述说明以及解释

java写入mongo double类型的数据是科学计数法-概述说明以及解释1.引言1.1 概述Java是一种广泛使用的编程语言，它支持多种数据类型，包括整数、浮点数、字符、布尔值等。

而MongoDB是一种NoSQL数据库系统，它以文档的形式存储数据。

在Java中，我们经常需要将数据写入MongoDB，其中涉及到Double类型的数据。

在Java写入MongoDB Double类型的数据时，有时会遇到科学计数法的表示方式。

科学计数法是一种十进制数字的表示方法，通过使用指数来表示很大或很小的数字。

例如，1.23E+6表示的是1.23乘以10的6次方，即1230000。

这种表示方式在科学和工程领域中经常使用，但在一些应用场景中可能会带来问题。

本文将探讨在Java中写入MongoDB Double类型数据时，使用科学计数法表示的问题，并提供解决方案。

我们将首先介绍Java中的数据类型，接着详细讨论MongoDB中的Double类型，最后深入探讨科学计数法在Java写入MongoDB Double类型数据的具体问题和解决方法。

通过本文的阅读，读者将了解到如何正确处理科学计数法表示的Double类型数据，避免数据存储错误或损失精度的问题。

同时，我们还将展望未来发展方向，探讨可能的改进和优化。

让我们开始探索吧！1.2 文章结构文章结构部分的内容如下：文章结构部分旨在介绍本篇长文的整体结构和内容安排。

本文总共包括三个主要部分：引言、正文和结论。

在引言部分，我们首先对文章进行了概述，简要介绍了本文要讨论的主题：Java写入MongoDB Double类型的数据时遇到的科学计数法的问题。

接着，我们阐述了文章的结构，即包括引言、正文和结论三个主要部分。

最后，我们明确了本文的目的，即旨在探讨科学计数法在Java写入MongoDB Double类型数据时的问题并提供解决方案。

在正文部分，我们将以两个主要方面展开讨论。

首先，我们将介绍Java 中的数据类型，包括基本数据类型和引用数据类型，以及Java中处理数据类型的特点。

persistenceexception selectlist

在软件开发中，`PersistenceException` 是一个常见的异常类型，通常与持久化操作（如数据库查询）相关。

在使用持久层框架（例如，Hibernate、MyBatis）进行数据库访问时，开发者可能会遇到`PersistenceException` 异常。

这个异常表示在持久层操作中发生了错误，而错误的根本原因可能是多方面的。

在这篇回答中，我们将讨论在进行数据库查询时可能引发`PersistenceException` 异常的情况，并提供解决方法。

### `PersistenceException` 异常简介`PersistenceException` 是Java 持久层操作中的异常类型之一，它通常是标准JPA（Java Persistence API）或其他持久层框架的异常之一。

这个异常的出现通常是因为在进行数据库查询时出现了问题，例如SQL 查询语句的执行失败、数据库连接问题、或者查询结果映射错误等。

### 可能导致`PersistenceException` 的情况#### 1. SQL 查询语句错误`PersistenceException` 可能由于SQL 查询语句的错误而引发。

这可能包括语法错误、表或字段名拼写错误、SQL 查询参数设置错误等。

当持久层框架执行SQL 查询时，如果底层数据库报告错误，就可能导致`PersistenceException` 异常的抛出。

```javatry {// 执行SQL 查询entityManager.createQuery("SELECT * FROM NonexistentTable", YourEntity.class).getResultList();} catch (PersistenceException e) {// 处理异常e.printStackTrace();}```#### 2. 数据库连接问题`PersistenceException` 还可能由于数据库连接问题而引发。

hibernate持久化对象的三种状态及描述

hibernate持久化对象的三种状态及描述摘要：I.引言A.介绍Hibernate 持久化对象B.介绍Hibernate 持久化对象的状态II.Hibernate 持久化对象的三种状态A.临时状态(Transient)1.定义2.特点3.示例B.持久状态(Persistent)1.定义2.特点3.示例C.游离状态(Detached)1.定义2.特点3.示例III.状态转换A.临时状态转换为持久状态1.对象实例化2.添加到Session 缓存3.提交事务B.持久状态转换为游离状态1.从Session 缓存中移除2.数据库更新3.对象失去联系C.游离状态转换为持久状态1.重新关联对象和数据库记录2.添加到Session 缓存3.提交事务IV.结论A.总结Hibernate 持久化对象的状态B.强调状态转换的重要性C.展望未来Hibernate 的发展正文：Hibernate 是一种流行的Java 持久化框架，它可以将Java 对象映射到关系型数据库中。

在Hibernate 中，持久化对象有三种状态：临时状态(Transient)、持久状态(Persistent) 和游离状态(Detached)。

理解这些状态对于掌握Hibernate 的运行机制至关重要。

临时状态(Transient) 是指对象刚刚被创建，还没有与数据库建立关联。

这种状态下的对象不包含任何数据库记录，也不在Session 缓存中。

当一个对象实例化后，它处于临时状态。

持久状态(Persistent) 是指对象已经与数据库建立了关联，并且存在于Session 缓存中。

当对象被添加到Session 缓存后，它就变成了持久状态。

此时，对象的变化会被同步到数据库中。

游离状态(Detached) 是指对象与数据库的关联已经断开，但是仍然存在于内存中。

这种状态下的对象不再受Session 缓存的管理，但是它仍然保持着与数据库记录的映射关系。

当对象从Session 缓存中移除，但是还没有被提交事务时，它处于游离状态。

Hibernate4开发文档

hibernate4简介开源的对象关系映射框架(ORM)hibernate 核心接口Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流SessionFactory接口SessionFactory接口负责初始化Hibernate。

它充当数据存储源的代理，并负责创建Session对象Configuration类Configuration类负责配置并启动Hibernate，创建SessionFactory 对象。

在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory对象Transaction接口Transaction接口负责事务相关的操作Query和Criteria接口Query和Criteria接口负责执行各种数据库查询。

它可以使用HQL语句或SQL语句两种表达方式。

hibernate 访问持久化类属性的策略accessproperty:field:hibernate 主键策略generator 主键生成器increment 自动增长数据类型long short intidentity sql server mysql自动增长long shorintnative 根据数据库的支持自动选择identity sequence hilo uuidhilo<generator class="hilo"><param name="table">hi_value</param><param name="column">next_value</param><param name="max_lo">100</param></generator>sequence 序列必须有一个序列名称assigned 自然主键主键由java程序指定hibernate 对象状态瞬时态瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系new 对象delete()持久态处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识save() saveOrUpdate() get() load()脱管态当一个session执行close()或clear()、evict()之后当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象关系hibernate4 注解和关系hibernate4 注解@Entity 表示该类是一个实体类@Table 映射成一张表不写参数默认表名跟类名相同@Table(name="t_people")@Id 表示主键@GeneratedValue(strategy=GenerationType.AUTO)(native)@Id@GeneratedValue(generator="seq_ganerator")@GenericGenerator(name="seq_ganerator",strategy="sequence",parameters={@Parameter(name="sequence",value="seq_people")})1、native@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "native")2、uuid@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "uuid") 3、hilo@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "hilo") 4、assigned@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "assigned")5、identity@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "identity")6、select@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name="select", strategy="select",parameters = { @Parameter(name = "key", value = "idstoerung") })7、sequence@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "sequence",parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })8、seqhilo@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "seqhilo", parameters = { @Parameter(name = "max_lo", value = "5") })9、increment@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "increment")10、foreign@GeneratedValue(generator = "idGenerator")@GenericGenerator(name = "idGenerator", strategy = "foreign", parameters = { @Parameter(name = "property", value = "employee") })@Transient该注解可以屏蔽属性的映射hibernate 延迟加载getget方法一要一执行就会发出sql get没有延迟加载如果对象不存在会抛出ng.NullPointerExceptionload调用load方法时并不会发出sql语句,只有在使用该对象时才发会sql, 当完成load之后,其实拿到的是一个代理对象,这个代理对象只有一个id值,获取对象的其它值时,才会发sql 语句load 用到了hibernate的延迟加载如果对象不存会抛出org.hibernate.ObjectNotFoundException:一对一关联OneToOne单向关联<many-to-one name="person" column="pid" unique="true" cascade="delete" ></many-to-one> 单向关联注解@OneToOne@JoinColumn(name="pid",unique=true)cascade属性的可选值：all : 所有情况下均进行关联操作。

java onnxruntime使用示例

java onnxruntime使用示例（原创版）目录1.ONNX Runtime 简介2.Java ONNX Runtime 的使用方法3.Java ONNX Runtime 的示例代码4.ONNX Runtime 的优势和未来发展正文1.ONNX Runtime 简介ONNX（Open Neural Network Exchange）Runtime 是一个用于加速深度学习模型的运行时，它可以在不同的硬件和操作系统上实现高性能、低延迟的模型推理。

ONNX Runtime 支持多种深度学习框架，如 TensorFlow、PyTorch 和 Keras 等，使得开发者可以轻松地将模型部署到不同的设备上。

2.Java ONNX Runtime 的使用方法Java ONNX Runtime 是 ONNX Runtime 的一个 Java 封装库，它为 Java 开发者提供了便捷的 API，使得开发者可以轻松地在 Java 程序中使用 ONNX Runtime 进行模型推理。

要使用 Java ONNX Runtime，首先需要添加 ONNX Runtime 的依赖，然后创建一个模型并进行推理。

3.Java ONNX Runtime 的示例代码以下是一个使用 Java ONNX Runtime 进行模型推理的简单示例：```javaimport org.onnxruntime.ONNXRuntime;import org.onnxruntime.model.Model;import org.onnxruntime.model.ModelBuilder;import org.onnxruntime.model.dtypes.DType;import org.onnxruntime.model.dtypes.DT_FLOAT;import org.onnxruntime.model.opset.OpSet;import org.onnxruntime.model.opset.impl.OpSetBuilder;import org.onnxruntime.model.graph.Graph;import org.onnxruntime.model.graph.Node;import org.onnxruntime.model.graph.op.Op;import org.onnxruntime.model.graph.op.core.Constant;import org.onnxruntime.model.graph.op.core.Placeholder;import org.onnxruntime.model.graph.op.math.Add;import org.onnxruntime.model.graph.op.math.Mul;import org.onnxruntime.session.InferenceSession;import org.onnxruntime.session.InferenceSessionBuilder;public class ONNXRuntimeExample {public static void main(String[] args) {// 创建一个模型Model model = ModelBuilder.create().with_opset(OpSetBuilder.create().with_op(Op.create("Mul", DT_FLOAT)).with_op(Op.create("Add", DT_FLOAT)).with_op(Op.create("Placeholder",DT_FLOAT)).with_op(Op.create("Constant", DT_FLOAT, 3.0f))).with_graph(GraphBuilder.create().with_node(Node.create(Op.get("Mul"), new int[]{0, 1})).with_node(Node.create(Op.get("Add"), new int[]{0, 1, 2})).with_node(Node.create(Op.get("Placeholder "), new int[]{1})).with_node(Node.create(Op.get("Constant"), new int[]{2}))).build();// 创建一个推理会话InferenceSession session =InferenceSessionBuilder.create().with_model(model).build();// 进行推理float[] input = {1.0f, 2.0f};float[] output = new float[1];session.run(input, {output});// 输出推理结果System.out.println("Result: " + output[0]);}}```4.ONNX Runtime 的优势和未来发展ONNX Runtime 的优势在于它可以在多种硬件和操作系统上实现高性能、低延迟的模型推理，同时支持多种深度学习框架。

java selectsinglenode 用法

java selectsinglenode 用法Java中的SelectSingleNode是用于选择XML文档中单个节点的常用方法。

它允许您根据指定的XPath表达式从XML文档中选择单个节点，并执行与该节点相关的操作。

下面是一个简单的示例，演示如何使用SelectSingleNode方法。

一、导入必要的库在使用SelectSingleNode方法之前，需要导入以下库：```javaimport javax.xml.XMLConstants;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.transform.dom.DOMSource;import javax.xml.xpath.XPath;import javax.xml.xpath.XPathConstants;import javax.xml.xpath.XPathExpression;import javax.xml.xpath.XPathFactory;```二、创建XML文档对象创建一个XML文档对象，用于存储要操作的XML数据。

可以使用DocumentBuilderFactory类创建一个新的DocumentBuilder对象，并使用它来构建XML文档对象。

```javaDocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();Document document = documentBuilder.newDocument();```三、创建XPath对象创建一个XPath对象，用于根据XPath表达式选择XML文档中的节点。

karate framework 介绍

karate framework 介绍Karate Framework 介绍Karate Framework是一个基于Java的开源测试框架，它结合了BDD（行为驱动开发）和Cucumber的特点。

Karate Framework的目标是简化测试过程，提供一个易于理解和使用的工具。

它能够与多种技术和工具集成，包括Java，Cucumber，API，数据库，UI等。

在本文中，我们将逐步回答Karate Framework的相关问题。

第一步：什么是Karate Framework？Karate Framework是一个轻量级的测试框架，它致力于简化API和UI 测试的编写和维护。

它使用简洁的DSL（领域特定语言），可以快速编写和运行测试用例。

Karate Framework提供了一个完整的解决方案，包括测试数据管理，HTTP请求，断言和报告生成等功能。

第二步：为什么选择Karate Framework？Karate Framework具有以下几个特点，使得它成为开发人员和测试人员的首选：1. 简单易用：Karate Framework使用简洁的语法，易于理解和编写。

它提供了丰富的断言工具，以及易于阅读和分析的测试报告。

2. 混合技术：Karate Framework不仅可以测试API，还可以测试UI和数据库。

它可以与多种技术和工具集成，包括Java，Cucumber，Selenium 等。

3. 自包含：Karate Framework在测试执行过程中，不需要任何外部依赖。

它提供了内置的Mock服务器和数据库引擎，方便测试人员进行功能测试和集成测试。

4. 数据驱动：Karate Framework支持数据驱动测试，可以通过表格或CSV文件传递多组测试数据。

这样可以轻松地测试不同的数据集和边界情况。

第三步：Karate Framework的主要特性是什么？Karate Framework具有许多强大的特性，使得它成为一个全面的测试框架。

持久化配置

持久化配置1.持久化对象 Persistent ObjectPO = POJO + hbm映射配置编写规则.①必须提供无参数public构造器.②所有属性private，提供public的getter和setter方法.③必须提供标识属性，与数据表中主键对应，例如Customer类id属性.④PO类属性应尽量使用基本数据类型的包装类型(区分空值) 例如int---Integer long---Long.⑤不要用final修饰（将无法生成代理对象进行优化）为什么？面试题：理解Session的get方法与load方法区别.@Test.// 测试session对象get 和load的区别.public void testGetAndLoad() {.Session session = HibernateUtils.openSession();.Transaction transaction = session.beginTransaction();..// 根据id 查询.Customer customer = (Customer) session.load(Customer.class, 1);.System.out.println(customer);.mit();.session.close();.}我们可以进行Debug查看cutomer对象，(断点设置在打印语句)session.get 方法，查询立即执行，返回Customer类对象session.load 方法，默认采用延迟加载数据方式，不会立即查询，返回Customer类子类对象（动态生成代理对象）* 如果 PO类使用final修饰，load无法创建代理对象，返回目标对象本身（load 效果和 get效果相同）2.理解OIDOID 指与数据表中主键对应 PO类中属性，例如 Customer类 id属性Hibernate框架使用OID来区分不同PO对象* 例如内存中有两个PO对象，只要具有相同 OID， Hibernate认为同一个对象* Hibernate 不允许缓存同样OID的两个不同对象3.区分自然主键和代理主键使用具有业务含义字段作为主键 ----- 自然主键，例如：身份证号，用户名(难维护)随机生成，不具备业务含义的字段 ----代理主键，例如流水号，UUID*** 现在企业系统，大多使用代理主键4.使用基本数据类型还是包装类型？使用基本类型，无法区分 0 和 null ，使用int类型分数，如果学生分数为0 可以没有考试，也可能考试得了0分使用包装类型，如果不设置数据，数据表存放null ，而不是默认值 0 * 以后开发中，PO类属性都使用包装类型。

spring4集成atomikos出现oracle.jdbc.driver.LogicalConnection.createClob异常

spring4集成atomiko3.9.1出现oracle.jdbc.driver.LogicalConnection.create Clob异常2015-05-26 15:49:07,538 [localhost-startStop-1] WARN [com.atomikos.jdbc.JdbcConnectionProxyHelper] - Error delegating 'createClob' callng.AbstractMethodError: oracle.jdbc.driver.LogicalConnection.createClob()Ljava/sql/Clob;at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)atsun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at ng.reflect.Method.invoke(Method.java:606)atcom.atomikos.jdbc.AtomikosConnectionProxy.invoke(AtomikosConnectionProxy.java:161) at com.sun.proxy.$Proxy73.createClob(Unknown Source)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)atsun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at ng.reflect.Method.invoke(Method.java:606)ateContextualLobCreation(LobCreatorBuild er.java:109)at org.hibernate.engine.jdbc.internal.LobCreatorBuilder.<init>(LobCreatorBuilder.java:61) at org.hibernate.engine.jdbc.internal.JdbcServicesImpl.configure(JdbcServicesImpl.java:157) atorg.hibernate.service.internal.StandardServiceRegistryImpl.configureService(StandardServiceReg istryImpl.java:75)atorg.hibernate.service.internal.AbstractServiceRegistryImpl.initializeService(AbstractServiceRegis tryImpl.java:159)atorg.hibernate.service.internal.AbstractServiceRegistryImpl.getService(AbstractServiceRegistryIm pl.java:131)at org.hibernate.cfg.SettingsFactory.buildSettings(SettingsFactory.java:78)at org.hibernate.cfg.Configuration.buildSettingsInternal(Configuration.java:2283)at org.hibernate.cfg.Configuration.buildSettings(Configuration.java:2279)atorg.springframework.orm.hibernate4.LocalSessionFactoryBuilder.buildSettings(LocalSessionFact oryBuilder.java:334)at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1748)at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1788)atorg.springframework.orm.hibernate4.LocalSessionFactoryBuilder.buildSessionFactory(LocalSessi onFactoryBuilder.java:363)atorg.springframework.orm.hibernate4.LocalSessionFactoryBean.buildSessionFactory(LocalSessio nFactoryBean.java:453)atorg.springframework.orm.hibernate4.LocalSessionFactoryBean.afterPropertiesSet(LocalSessionF actoryBean.java:438)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMeth ods(AbstractAutowireCapableBeanFactory.java:1627)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean( AbstractAutowireCapableBeanFactory.java:1564)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean( AbstractAutowireCapableBeanFactory.java:540)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:476)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:198)atmonAnnotationBeanPostProcessor.autowireResourc e(CommonAnnotationBeanPostProcessor.java:446)atmonAnnotationBeanPostProcessor.getResource(Co mmonAnnotationBeanPostProcessor.java:420)atmonAnnotationBeanPostProcessor$ResourceElemen t.getResourceToInject(CommonAnnotationBeanPostProcessor.java:545)atorg.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(Injection Metadata.java:155)atorg.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:87 )atmonAnnotationBeanPostProcessor.postProcessPrope rtyValues(CommonAnnotationBeanPostProcessor.java:305)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean( AbstractAutowireCapableBeanFactory.java:1204)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean( AbstractAutowireCapableBeanFactory.java:538)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:476)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:193)atorg.springframework.beans.factory.support.DefaultListableBeanFactory.findAutowireCandidates( DefaultListableBeanFactory.java:1081)atorg.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(D efaultListableBeanFactory.java:1006)atorg.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(Defa ultListableBeanFactory.java:904)atorg.springframework.beans.factory.support.ConstructorResolver.resolveAutowiredArgument(Con structorResolver.java:815)atorg.springframework.beans.factory.support.ConstructorResolver.createArgumentArray(Constructo rResolver.java:743)atorg.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(Constructor Resolver.java:185)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstr uctor(AbstractAutowireCapableBeanFactory.java:1133)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInst ance(AbstractAutowireCapableBeanFactory.java:1036)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean( AbstractAutowireCapableBeanFactory.java:505)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:476)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:193)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(Bean DefinitionValueResolver.java:328)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessar y(BeanDefinitionValueResolver.java:108)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyV alues(AbstractAutowireCapableBeanFactory.java:1471)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean( AbstractAutowireCapableBeanFactory.java:1216)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:538)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:476)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:193)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(Bean DefinitionValueResolver.java:328)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessar y(BeanDefinitionValueResolver.java:108)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveManagedList(Be anDefinitionValueResolver.java:359)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessar y(BeanDefinitionValueResolver.java:157)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyV alues(AbstractAutowireCapableBeanFactory.java:1471)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean( AbstractAutowireCapableBeanFactory.java:1216)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean( AbstractAutowireCapableBeanFactory.java:538)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:476)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:193)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(Bean DefinitionValueResolver.java:328)atorg.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessar y(BeanDefinitionValueResolver.java:108)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyV alues(AbstractAutowireCapableBeanFactory.java:1471)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean( AbstractAutowireCapableBeanFactory.java:1216)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean( AbstractAutowireCapableBeanFactory.java:538)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:476)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:198)atorg.springframework.aop.framework.autoproxy.BeanFactoryAdvisorRetrievalHelper.findAdvisor Beans(BeanFactoryAdvisorRetrievalHelper.java:92)atorg.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator.findCandidate Advisors(AbstractAdvisorAutoProxyCreator.java:101)atorg.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator.shouldSkip( AspectJAwareAdvisorAutoProxyCreator.java:103)atorg.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessBeforeInst antiation(AbstractAutoProxyCreator.java:241)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPost ProcessorsBeforeInstantiation(AbstractAutowireCapableBeanFactory.java:977) atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.resolveBeforeI nstantiation(AbstractAutowireCapableBeanFactory.java:948)atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(Ab stractAutowireCapableBeanFactory.java:466)atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactor y.java:302)atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSi ngletonBeanRegistry.java:229)atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory .java:298)atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.ja va:198)atorg.springframework.context.support.PostProcessorRegistrationDelegate.registerBeanPostProcess ors(PostProcessorRegistrationDelegate.java:232)atorg.springframework.context.support.AbstractApplicationContext.registerBeanPostProcessors(Ab stractApplicationContext.java:615)atorg.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationCo ntext.java:465)atorg.springframework.web.context.ContextLoader.configureAndRefreshWebApplicationContext(C ontextLoader.java:403)atorg.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java: 306)atorg.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:106)at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4797) at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5291) at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150)at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1559) at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1549) at java.util.concurrent.FutureTask.run(FutureTask.java:262)at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615) at ng.Thread.run(Thread.java:745)后来来是ojdbc14-10.2.0.1.0.jar驱动的问题，换成ojdbc6.jar启动就没有这个问题了。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Use exclude instead of lห้องสมุดไป่ตู้yerDependencies and keepRequires
Resourse Tags
-test
The resource is part of the test code for the package.
-copyOnly
The resource should be copied to the destination location and otherwise left unaltered.
Agenda
Introduction to bdBuild and Dojo new builder Build Profile in Dojo 1.6 Build Control Script in Dojo 1.7
How does the new build system work?
Customize the build process.
Agenda
Introduction to bdBuild and Dojo new builder Build Profile in Dojo 1.6 Build Control Script in Dojo 1.7
How does the new build system work?
Customize the build process.
"lib": "."
}, "version" : "1.7.2", "dojoBuild": "dojo.profile.js"
}
build.bat --package ../../dojo build.bat --package ../../dojo, ../../dijit
Useful Command Link Swtich
-amd
The resource is an AMD module.
-miniExclude
The resource should not be copied to the destination if the profile property "mini" is truthy.
Conditional Exclusions
excludeStart( tag , `` *condition* ``) excludeEnd( tag )
excludeStart( tag , "Tag", yers.length > 1) ... code within the region here will be ignored excludeEnd( tag )
•Use batch program or shell script ~/dev/dtk/util/buildscripts> ./build.sh --help (nodeJS is preferred, otherwise Rino will be userd) ~/dev/dtk/util/buildscripts> ./build.bat --help
Build Profile in Dojo 1.6
/buildscripts/profile/myprofile.profile.js
dependencies = { layers: [ { name: "test.js", dependencies: [ "test.ModuleA", "test.ModuleB", "test.ModuleC" ] } ], prefixes: [ [ "test", "../test" ] ] }
How does the new build system work?
Customize the build process.
Introduction to bdBuild and Dojo new builder
•Dojo 1.7 builder is based on the bdBuilder which done by Rawld Gill •bdBuild is a general-purpose program for transforming resources •Build process -Discover resources -Apply transforms •Highly configurable - Build Control Script (BCS, the new Build Profile!)
layerDependencies
dependencies = { layers: [{ name: "part1.js", resourceName: "test.part1", dependencies: [ "test.ModuleA", "test.ModuleB" ] },{ name: "part2.js", resourceName: "test.part2", dependencies: [ "test.ModuleC", "test.ModuleD" ], layerDependencies: [ "test/part1.js" ] }], prefixes: [ [ "test", "../test" ] ] }
How does the new build system work?
Customize the build process.
Agenda
Introduction to bdBuild and Dojo new builder Build Profile in Dojo 1.6 Build Control Script in Dojo 1.7
keepRequires
dependencies = { layers: [{ name: "part1.js", resourceName: "test.part1", dependencies: [ "test.ModuleA", "test.ModuleB" ]},{ name: "part2.js", resourceName: "test.part2", dependencies: [ "test.ModuleC", "test.ModuleD" ], layerDependencies: [ "test/part1.js" ], keepRequires: [ "dojo.i18n" ]} ], prefixes: [ [ "test", "../test" ], [ "dijit", "../dijit" ] ] }
},{ name:"dijit", location:"../../../dijit"
}]
}; build.bat --dojoConfig ../build/exapmles/dojoConfig.js
Useful Command Link Swtich
•--package path
/dojo/package.json { "directories": {
•--releaseDir *directory* •--check •--help •--version
•--release
build.bat --profile yourprofile --release Note: The action clean is no longer supported.
Useful Command Link Swtich
•--profile profile-name
build.bat --profile yourprofile.profile.js build.bat --profile yourprofile build.bat --profile yourprofile1 --profile yourprofile2
packages
var profile = { packages: [{ name: 'dojo', location: '../dojo' },{ name: 'test', location: '../test' }], layers: { 'test/part1': { include: [ 'test/ModuleA', 'test/ModuleB' ]}, 'test/part2': { include: [ 'test/ModuleC', 'test/ModuleD'], exclude: [ 'test/part1' ] }}
Useful Command Link Swtich
•--dojoConfig filename
/util/build/examples/dojoConfig.js var dojoConfig = { packages:[{ name:"dojo",
location:"../../../dojo"
Invoking the Build System
•Use nodeJS