随笔-12  评论-1  文章-0  trackbacks-0
  2011年8月26日
1.logger.info(LogUtils.getLogFmt("ResponseXML", "ResultCode",
     "ErrorDesc", "ServiceType", "Version"), new Object[] {
     rs.getResponseXML(), rs.getResultCode(), rs.getErrorDesc(),
     rs.getServiceType(), rs.getVersion() });
2.logger.error("error when call webservice: " + serviceType, e);
3.logger.info(LogUtils.getLogFmt("RequestXML"), requestXML);
posted @ 2012-09-04 18:44 小熊宝贝的每一天 阅读(169) | 评论 (0)编辑 收藏
ID属性的声明必须被置于最后
<xs:attribute name="orderid" type="xs:string" use="required"/>

ComplexContent的用法:

<?xml version="1.0" encoding="UTF-8"?>
<xs:element name="employee" type="fullpersoninfo"/>

<xs:complexType name="personinfo">
  <xs:sequence>
    <xs:element name="firstname" type="xs:string"/>
    <xs:element name="lastname" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

<xs:complexType name="fullpersoninfo">
  <xs:complexContent>
    <xs:extension base="personinfo">
      <xs:sequence>
        <xs:element name="address" type="xs:string"/>
        <xs:element name="city" type="xs:string"/>
        <xs:element name="country" type="xs:string"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

posted @ 2012-08-21 17:23 小熊宝贝的每一天 阅读(167) | 评论 (0)编辑 收藏
1.
准确说是一种Java XML数据绑定技术。
http://www.iteye.com/topic/582459
:
<bind-xml name="borndate" node="attribute"/> ,name规定了这个值在xml中的显示名,而node规定了该值的xml存储方式,这里是用attribute形式进行存储,即写到了结点的属性里。   
2.Castor介绍----比较详细易懂的BLOG:
http://www.open-open.com/lib/view/open1326514404093.html

mapping.xml配置如下:  
01<?xml version="1.0" encoding="UTF-8"?>
02<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN" "http://castor.org/mapping.dtd">
03<mapping>
04    <class name="com.hoo.entity.Account" auto-complete="true"
05        <map-to xml="Account"/>
06
07        <field name="id" type="integer">
08            <bind-xml name="id" node="attribute" />
09        </field>
10
11        <field name="name" type="string">
12            <bind-xml name="name" node="element" />
13        </field>
14
15        <field name="email" type="string">
16            <bind-xml name="email" node="element" />
17        </field>
18
19        <field name="address" type="string">
20            <bind-xml name="address" node="element" />
21        </field>
22
23        <field name="birthday" type="com.hoo.entity.Birthday">
24            <bind-xml name="生日" node="element" />
25        </field>
26    </class>
27
28    <class name="com.hoo.entity.Birthday">
29        <map-to xml="birthday" />
30
31        <field name="birthday" type="string">
32            <bind-xml name="birthday" node="attribute" />
33        </field>
34    </class>
35</mapping>


首先,看看这个xml文档的根元素是mapping,在mapping中可以配置class。也就是我们要转换的JavaObject的配置描述了。  

class元素的name属性就是配置的JavaObject的classpath路径了。  

关于class元素的auto-complate属性,如果这个属性的值为ture。那么编组后的xml,castor会自动给没有在mapping配置文件进行配置的属性自动编组(转换)到xml中。如果为false,那么在mapping配置文件中出现的属性将在编组后不现在在编组后的xml中。  

map-to就是当前class编组后的xml文档的节点元素名称。  

field就是描述JavaObject中的属性,name是Java对象的属性名称,type是类型。关于配置的type类型也有规定,你可以参考:http://www.castor.org/xml-mapping.html的field配置讲解。  

而field还有其他的属性配置,如get-method应该是getter方法、set-method应该是setter的方法、has-mehtod 应该是hashCode方法,有时候我们不一定要提高getter、setter方法,我们需要用自己的方法名称来代替setter、getter。如果当前field配置的是集合类型,那么你需要给field元素配置collection属性。  

bind-xml就是绑定(编组)成xml后的xml内容的描述,name就是编组后xml的节点元素名称,node有2个值,分别是 attribute、element。attribute是属性,它会在节点元素的属性中显示,例如:<account id=”2”></account>  

而element则是单独的一个元素,例如:<account><id>2</id></account>  

就这个样子的。  

mapping.xml还可以有其他标签,如:  

<include href="other_mapping_file.xml"/>  

导入外部xml文件,可以分多个配置。  




 

posted @ 2012-08-21 16:01 小熊宝贝的每一天 阅读(293) | 评论 (0)编辑 收藏

AnyURI 数据类型(AnyURI Data Type)

anyURI 数据类型用于规定 URI。

下面是一个关于某个 scheme 中 anyURI 声明的例子:

<xs:attribute name="src" type="xs:anyURI"/>

文档中的元素看上去应该类似这样:

<pic src="http://www.w3school.com.cn/images/smiley.gif" />
 

XML Schema 是基于 XML 的 DTD 替代者。

XML Schema 描述 XML 文档的结构。

XML Schema 语言也称作 XML Schema 定义(XML Schema Definition,XSD)。

在此教程中,你将学习如何在应用程序中读取和创建 XML Schema 语言,XML Schema 为何比 DTD 更加强大,以及如何在您的应用程序中使用 XML Schema。

XML中的Schema元素详解:
http://www.w3school.com.cn/schema/schema_schema.asp
posted @ 2012-08-15 13:07 小熊宝贝的每一天 阅读(180) | 评论 (0)编辑 收藏
XML Schema:
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3school.com.cn"
xmlns="http://www.w3school.com.cn"
elementFormDefault="qualified">

<xs:element name="note">
    <xs:complexType>
      <xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="heading" type="xs:string"/>
<xs:element name="body" type="xs:string"/>
      </xs:sequence>
    </xs:complexType>
</xs:element>

</xs:schema>



 

 

定义简易元素

定义简易元素的语法:

<xs:element name="xxx" type="yyy"/>
  • xs:string
  • xs:decimal
  • xs:integer
  • xs:boolean
  • xs:date
  • xs:time

  •  定义属性

    <xs:attribute name="lang" type="xs:string" fixed="EN"/>


    限定(restriction)用于为 XML 元素或者属性定义可接受的值。对 XML 元素的限定被称为 facet。

    使用 extension 或 restriction 元素来扩展或限制元素的基本简易类型。






     

    posted @ 2012-08-14 17:49 小熊宝贝的每一天 阅读(195) | 评论 (0)编辑 收藏
    WSDL是Web Service的描述语言,是一种接口定义语言,用于描述Web Service的接口信息等。WSDL元素[1]基于XML语法描述了与服务进行交互的基本元素
      Type(消息类型):数据类型定义的容器,它使用某种类型系统(如XSD)。
      Message(消息):通信数据的抽象类型化定义,它由一个或者多个part组成。
      Part:消息参数

          Operation(操作):对服务所支持的操作进行抽象描述,WSDL定义了四种操作:
    1.单向(one-way):端点接受信息;2.请求-响应(request-response):端点接受消息,然后发送相关消息;3.要求-响应(solicit-response):端点发送消息,然后接受相关消息;4.通知(notification
    ):端点发送消息。
      Port Type (端口类型):特定端口类型的具体协议和数据格式规范。
      Binding:特定端口类型的具体协议和数据格式规范
      Port :定义为绑定和网络地址组合的单个端点。
      Service:相关端口的集合,包括其关联的接口、操作、消息等。
    posted @ 2012-08-14 14:57 小熊宝贝的每一天 阅读(172) | 评论 (0)编辑 收藏

    HQL(Hibernate Query Language):是面向对象的查询语句,它的语法和SQL语句有些相像,在运行时才得以解析.HQL并不像SQL那样是数据操作语言,它用来取得对象,而不是进行update,delete和insert操作. HQL 是一门对大小写不敏感的的语言,所以SeLect与SELECT和sELeCT是相同的.


    ----------------
    现在有四张表:student,team,course,student_course.

    student 表中有五个字段,分别是:id,name,cardId,age,team_id;   
    team      表中有两个字段,id,teamname;
    course 表中有id,name;
    student_course 表中有stu_id,course_id;      保存多对多的关系表
    ----------------

    Student 是一个对象,student 是数据库中的一个表.

    查询所有的Student对象时,最简单的HQL语句是: from Student,也可以写成 select s from Student (as)s. 注:这的as可以省略

     


    1:简单的查询遍历对象:

    遍历Student

    Query query=session.createQuery("form Student");       //注: 如果Student对象不是唯一的,那么需要写上包名,如: from test.Student      test为包名.
    List list=query.list();
    for(int i=0;i<list.size();i++)
    {
    Student stu=(Student)list.get(i);
    System.out.println(stu.getName());
    }

    注意: 如果执行HQL语句"from Student,Course",并不时单单返回两个对象,而是返回两个对象的笛卡尔积,这类似SQL语句中字段的全外连接.实际的应用中,"from Student,Course"这种语句几乎是不回出现的.


    2:属性查询:

          ----单个属性查询:

    Query query=session.createQuery("select s.name form Student s");
    List list=query.list();
    for(int i=0;i<list.size();i++)
    {
    String name=(String)list.get(i);
    System.out.println(name);
    }

          ----多个属性查询:

    Query query=session.createQuery("select s.name,s.age form Student s");
    List list=query.list();
    for(int i=0;i<list.size();i++)
    {
    Object obj[]=(Object[])list.get(i);       //取得list中的第i个对象
    System.out.println(obj[0]+"的年龄为: "+obj[1]);
    }


    3:实例化查询:

    实例化查询结果可以说是对属性查询的一重改进.在使用属性查询时由于使用对象数组,操作和理解不太方便,如果将以个Object[]中的成员封装成一个对象就方便多了.

    Query query=session.createQuery("select new Student(s.name,s.age) form Student s");
    List list=query.list();
    for(int i=0;i<list.size();i++)
    {
    Student stu=(Student)list.get(i);
    System.out.println(stu.getName());
    }

    注:运行这个程序的时候,需要一个new Student(s.name,s.age)构造函数.在Student.java中编写这个构造函数.
    public Student(String name,int age)
    {
    this.name=name;
    this.age=age;
    }

     

    4:查询链接:

    与SQL查询一样,HQL也支持连接查询,如内连接,外连接和交叉连接.支持的链接类型是从ANSI SQL中借鉴来的.

          1: inner jion      (内连接)
    2: left outer join (左外连接)
    3: right outer join(右外连接)
    4: full join(全连接--不常用)

    inner jion 可以简写为join.

    正常情况下必须要建关联。


    select a.id, b.id from A a, B b where a.id = b.id;
    上面每条记录返回的是一个Object[]对象。
    你也可以把结果重新封装一下。
    String hql = "select a.id, b.id from A a, B b where a.id = b.id";
    List result = getHibernateTemplate().find(hql);
    if (result.size() > 0) {
    for (int i = 0; i < result.size(); i++){
    Object[] obj = (Object[]) result.get(i);
    //这里就可以重新封装数据
    }
    }


    5:统计函数查询:

    1: count()       统计记录的条数
    2: min() 求最小值
    3: max() 求最大值
    4: sum() 求和
    4: avg() 求平均值

    //取得Student的数量
    Query query=session.createQuery("select count(*) from Student")  

    //avg()取得Student平均年龄
    Query query=session.createQuery("select avg(s.age) from Student as s")  

    //upper()方法将字符串转为大写
    Query query=session.createQuery("select upper(s.name) from Student as s")  

    //去除重复行distinct
    Query query=session.createQuery("select distinct s.age from Student as s")  

     


    6:子查询:
    all 表示所有记录
    any 便是所有记录中的任意一条
    somy 与any用法一样
    in 等价于any
    exists 表示子查询至少要返回一条数据.


    all:

    from Team t where 22<all(select s.age from Student s)

    from Team t where all(select s.age from      t.student s)>22

     


    7:修改

    update()

    Student stu=(Student)session.get(Student.class,"id");      //根据id 得到stu对象
    stu.setName("123");
    session.update(stu);


    8:删除:

     

    delete()

    Student stu=(Student)session.get(Student.class,"id");      //根据id 得到stu对象
    session.delete(stu);

    posted @ 2011-11-19 15:20 小熊宝贝的每一天 阅读(219) | 评论 (0)编辑 收藏
         摘要: 看这个链接作了解:http://zhaohe162.blog.163.com/blog/static/3821679720110251181721/一、HQL查询的from子句 from是最简单的语句,也是最基本的HQL语句。from关键字后紧跟持久化类的类名。 例如: from Person  表明从Person持久化类中选出全部的实例 推荐为Person持久化类的每个实例起别...  阅读全文
    posted @ 2011-11-19 14:05 小熊宝贝的每一天 阅读(4523) | 评论 (1)编辑 收藏

    Hibernate的核心接口之一

      SessionFactory接口:SessionFactroy接口负责初始化Hibernate。它充当数据存储源的代理,并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory.

    示例如下:
      /**
      *@param str
      *@param int
      *更新String类型的字段
      */
      public int updateDm_bm(String str){
      int resu=0;
      //获取会话工厂
      SessionFactory sf=this.getSessionFactory();
      //获取SessionFactory的会话
      Session session=(Session)this.getSessionFactory().getCurrentSession();
      sf.openSession();
      //开始事务
      Transaction t=session.beginTransaction();
      Query query =session.createQuery(str);
      //提交事务
      resu=query.executeUpdate();
      // Query.executeUpdate()方法返回的整型值表明了受此操作影响
      return resu;
      }
      此方法如果传入一条数据修改语句。就可以直接执行返回成功与否的结果。
      而此处的SessionFactory一旦声明,就不必去估计数据库连接的问题,很方便。
    二、getHibernateTemplate 
          http://www.cnblogs.com/JemBai/archive/2011/01/17/1937413.html
    posted @ 2011-11-19 13:59 小熊宝贝的每一天 阅读(165) | 评论 (0)编辑 收藏
    1.Class.forname()----调用该访问返回一个以字符串指定类名的类的对象。

       在Java开发特别是数据库开发中,经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态加载类。在加载完成后,一般还要调用Class下的newInstance( )静态方法来实例化对象以便操作。因此,单单使用Class.forName( )是动态加载类是没有用的,其最终目的是为了实例化对象。 
       Important Point 1:Class.forName("")返回的是类 
                                 Class.forName("").newInstance()返回的是object

    Class.forName("");的作用是要求JVM查找并加载指定的类,如果在类中有静态初始化器的话,JVM必然会执行该类的静态代码 段。而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己,即任何一个JDBC Driver的 Driver类的代码都必须类似如下:
      public class MyJDBCDriver implements Driver {
       static {
         DriverManager.registerDriver(new MyJDBCDriver());
      }
      }
    既然在静态初始化器的中已经进行了注册,所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。


    posted @ 2011-11-19 13:31 小熊宝贝的每一天 阅读(178) | 评论 (0)编辑 收藏
    Software entities should be open for extension,but closed for modification.
    意思是说,一个软件实体应当对扩展开放,对修改关闭.也就是说,我们在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展,换句话说就是,应当可以在不必修改源代码的情况下改变这个模块的行为.
    满足OCP的设计给系统带来两个无可比拟的优越性.
      1.通过扩展已有的软件系统,可以提供新的行为,以满足对软件的新需求,使变化中的软件系统有一定的适应性和灵活性.
      2.已有的软件模块,特别是最重要的抽象层模块不能再修改,这就使变化中的软件系统有一定的稳定性和延续性.
    例如:
      编程模式中的工厂模式的“工厂方法”支持OCP原则
    posted @ 2011-08-26 13:27 小熊宝贝的每一天 阅读(146) | 评论 (0)编辑 收藏

    首先你要明白在java里面任何class都要装载在虚拟机上才能运行。这句话就是装载类用的(和new 不一样,要分清楚)。 

    至于什么时候用,你可以考虑一下这个问题,给你一个字符串变量,它代表一个类的包名和类名,你怎么实例化它?只有你提到的这个方法了,不过要再加一点。 
    A a = (A)Class.forName("pacage.A").newInstance(); 
    这和你 
    A a = new A(); 
    是一样的效果。 

    关于补充的问题 
    答案是肯定的,jvm会执行静态代码段,你要记住一个概念,静态代码是和class绑定的,class装载成功就表示执行了你的静态代码了。而且以后不会再走这段静态代码了。

    Class.forName(xxx.xx.xx) 返回的是一个类 
    Class.forName(xxx.xx.xx);的作用是要求JVM查找并加载指定的类,也就是说JVM会执行该类的静态代码段

    动态加载和创建Class 对象,比如想根据用户输入的字符串来创建对象 
    String str = 用户输入的字符串 
    Class t = Class.forName(str); 
    t.newInstance();

     在初始化一个类,生成一个实例的时候,newInstance()方法和new关键字除了一个是方法,一个是关键字外,最主要有什么区别?它们的区别在于创建对象的方式不一样,前者是使用类加载机制,后者是创建一个新类。那么为什么会有两种创建对象方式?这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。 

    Java中工厂模式经常使用newInstance()方法来创建对象,因此从为什么要使用工厂模式上可以找到具体答案。 例如: 
    class c = Class.forName(“Example”); 
    factory = (ExampleInterface)c.newInstance(); 

    其中ExampleInterface是Example的接口,可以写成如下形式: 
    String className = "Example"; 
    class c = Class.forName(className); 
    factory = (ExampleInterface)c.newInstance(); 

    进一步可以写成如下形式: 
    String className = readfromXMlConfig;//从xml 配置文件中获得字符串 
    class c = Class.forName(className); 
    factory = (ExampleInterface)c.newInstance(); 

    上面代码已经不存在Example的类名称,它的优点是,无论Example类怎么变化,上述代码不变,甚至可以更换Example的兄弟类Example2 , Example3 , Example4……,只要他们继承ExampleInterface就可以。 

    从JVM的角度看,我们使用关键字new创建一个类的时候,这个类可以没有被加载。但是使用newInstance()方法的时候,就必须保证:1、这个类已经加载;2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的,这个静态方法调用了启动类加载器,即加载 java API的那个加载器。 

    现在可以看出,newInstance()实际上是把new这个方式分解为两步,即首先调用Class加载方法加载某个类,然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性,提供给了一种降耦的手段。 

    最后用最简单的描述来区分new关键字和newInstance()方法的区别: 
    newInstance: 弱类型。低效率。只能调用无参构造。 
    new: 强类型。相对高效。能调用任何public构造。

    下面内容转自
    http://blog.csdn.net/iceman1952/archive/2007/03/07/1523025.aspx
    介绍的是 forName() 和 ClassLoader 的 loadClass 方法。
    现在终于知道了为什么
    forName()是会执行 static 语句,因为默认情况它总是初始化这个被装载的类。

    关于forName()方法
    这个方法总是返回要加载的类的Class类的实例
    1、forName(String className)单参数时, initialize=true
        a.总是使用当前类装载器(也就是装载执行forName()请求的类  的类装载器)
        b.总是初始化这个被装载的类(当然也包括:装载、连接、初始化)
    2、forName(String className, boolean initialize, ClassLoader loader)
        a.loader指定装载参数类所用的类装载器,如果null则用bootstrp装载器。
        b.initialize=true时,肯定连接,而且初始化了;
        c.false时,绝对不会初始化,但是可能被连接了,但是这里有个例外,如果在调用这个forName()前,已经被初始化了,那么返回的类型也肯定是被初始化的(当然,这里也暗含着:被同一个loader所装载的,而且这个类被初始化了)

    关于用户自定义的类装载器的loadClass()方法
    1、loadClass(String name)单参数时, resolve=false
        a.如果这个类已经被这个类装载器所装载,那么,返回这个已经被装载的类型的Class的实例,否则,就用这个自定义的类装载器来装载这个class,这时不知道是否被连接。绝对不会被初始化
        b.这时唯一可以保证的是,这个类被装载了。但是不知道这个类是不是被连接和初始化了
    2、loadClass(String name, boolean resolve)
        a.resolve=true时,则保证已经装载,而且已经连接了。resolve=falses时,则仅仅是去装载这个类,不关心是否连接了,所以此时可能被连接了,也可能没有被连接




    终于明白为什么加载数据库驱动只用Class.forName()了!!困扰了我2个小时!!希望我写的这个东西对各位有所帮助。

      
       在Java开发特别是数据库开发中,经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态加载类。在加载完成后,一般还要调用Class下的newInstance( )静态方法来实例化对象以便操作。因此,单单使用Class.forName( )是动态加载类是没有用的,其最终目的是为了实例化对象。
       这里有必要提一下就是Class下的newInstance()和new有什么区别?,首先,newInstance( )是一个方法,而new是一个关键字,其次,Class下的newInstance()的使用有局限,因为它生成对象只能调用无参的构造函数,而使用 new关键字生成对象没有这个限制。
       好,到此为止,我们总结如下:
       Class.forName("")返回的是类
       Class.forName("").newInstance()返回的是object
       有数据库开发经验朋友会发现,为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢?即有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一 些:Class.forName(xxx.xx.xx).newInstance(),为什么会有这两种写法呢?
       刚才提到,Class.forName("");的作用是要求JVM查找并加载指定的类,如果在类中有静态初始化器的话,JVM必然会执行该类的静态代码 段。而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己,即任何一个JDBC Driver的 Driver类的代码都必须类似如下:
      public class MyJDBCDriver implements Driver {
       static {
         DriverManager.registerDriver(new MyJDBCDriver());
      }
      }
    既然在静态初始化器的中已经进行了注册,所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。

    posted @ 2011-08-26 10:12 小熊宝贝的每一天 阅读(825) | 评论 (0)编辑 收藏