licream's blog » 网络相关

解析xpo生成xml文件

Licream — Wed, 01 Sep 2010 02:24:12 +0000

最近在做一个跟项目有关的小工具,是将另一种(xpo)格式的文件转化成xml文件,头几天没点头绪,一直以为用正则表达式可以快速解决这些问题,经过尝试阿根本不行. …其实我对正则表达式也不懂.哈哈.

发一部分xpo文件的格式,细心的会发现,这格式还是很有规律的,这样.我们解析过程中遇到的问题会少些.我要得到的数据是#号前后的内容,及他的类型.并将它们写在xml文件里面…
在处理xml文件上,我选用dom4j.读取xpo文件用BufferedReader的readLine方法．

Exportfile for AOT version 1.0 or later
Formatversion: 1

***Element: DBE

; Microsoft Business Solutions-Axapta Enumtype : ABC unloaded at Tuesday 2010-08-17
; --------------------------------------------------------------------------------
  ENUMTYPEVERSION 1

  ENUMTYPE #ABC
    PROPERTIES
      Name                #ABC
      Label               #@SYS69410
      Help                #
      DisplayLength       #Auto
      Style               #Combo box
      ConfigurationKey    #
      UseEnumValue        #No
    ENDPROPERTIES

    TYPEELEMENTS
      #None
      PROPERTIES
        Name                #None
        Label               #@SYS1369
        ConfigurationKey    #
        EnumValue           #0
      ENDPROPERTIES

      #A
      PROPERTIES
        Name                #A
        Label               #@SYS22523
        ConfigurationKey    #
        EnumValue           #1
      ENDPROPERTIES

      #B
      PROPERTIES
        Name                #B
        Label               #@SYS22524
        ConfigurationKey    #
        EnumValue           #2
      ENDPROPERTIES

      #C
      PROPERTIES
        Name                #C
        Label               #@SYS22525
        ConfigurationKey    #
        EnumValue           #3
      ENDPROPERTIES

    ENDTYPEELEMENTS
  ENDENUMTYPE

***Element: DBE

; Microsoft Business Solutions-Axapta Enumtype : ABCModel unloaded at Tuesday 2010-08-17
; --------------------------------------------------------------------------------
  ENUMTYPEVERSION 1

  ENUMTYPE #ABCModel
    PROPERTIES
      Name                #ABCModel
      Label               #@SYS23230
      Help                #@SYS23230
      DisplayLength       #Auto
      Style               #Combo box
      ConfigurationKey    #
      UseEnumValue        #No
    ENDPROPERTIES

    TYPEELEMENTS
      #Revenue
      PROPERTIES
        Name                #Revenue
        Label               #@SYS10074
        ConfigurationKey    #
        EnumValue           #0
      ENDPROPERTIES

      #ContributionMargin
      PROPERTIES
        Name                #ContributionMargin
        Label               #@SYS16226
        ConfigurationKey    #
        EnumValue           #1
      ENDPROPERTIES

      #Value
      PROPERTIES
        Name                #Value
        Label               #@SYS11762
        ConfigurationKey    #
        EnumValue           #2
      ENDPROPERTIES

      #Link
      PROPERTIES
        Name                #Link
        Label               #@SYS14545
        ConfigurationKey    #
        EnumValue           #3
      ENDPROPERTIES

    ENDTYPEELEMENTS
  ENDENUMTYPE

写的一个通用方法，定义Document ,SAXReader 用于读取xml文件,定义XMLWriter 写入xml文件

public static Document getDocument(String filename)
			throws DocumentException, IOException, XmlPullParserException {
		Document document = null;
		Document doc = DocumentHelper.createDocument();
		SAXReader sa = new SAXReader();
		XPP3Reader xp = new XPP3Reader();

		document = sa.read(new File(filename));

		return document;
	}

public static boolean saveDocument(String filename, Document doc) {
		try {
			OutputFormat out = OutputFormat.createPrettyPrint();
			XMLWriter writer = new XMLWriter(new FileOutputStream(filename),
					out);
			writer.write(doc);
			writer.close();
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

filename是xml文件.用于传入文件路径和名称.
Document doc = DocumentHelper.createDocument();注意这个,虽然没有用上.但实现这步,性能上有优化的效果,一位牛人是这么说的.我在使用时没感觉到.
SAXReader ,XPP3Reader ,后者处理信息快些.但是我改成它时报xml文件格式不规律.只好放弃使用改SAXReader.
如果你的xml文件有中文或以后添加有中文的信息,一定要用FileOutputStream来写入.否则报类型异常.

public String extendsDataTypeToXml(String filexpo, String filexml,
			String type) throws DocumentException, IOException, XmlPullParserException {

		Document document = DocumentOperator.getDocument(filexml);

		Element getroot = document.getRootElement();
		Element node = null;

		BufferedReader reader = null;
		String tempString = null;

		try {
			Element elementtion = null;
			String itemtype = null;
			String basetype = null;
			// 指定解析文件
			reader = new BufferedReader(new FileReader(new File(filexpo)));
			// 按行读取,直到读到null...
			while ((tempString = reader.readLine()) != null) {

				String str = "  ";// 截取字段规则,这里是获取该值后面的字符串.
				// 判断份该变量值开始,并从变值+enumtype字符串开始.此行还要包含#字符串.

				// case 1
				if (tempString.trim().equals("")
						|| tempString.trim().equals(null))
					continue;
                                    //startsWith方法是从每行内指定的地方开始执行,contains是指包含什么字符串.
				if (tempString.startsWith(str)
						&& tempString.startsWith(str + type)
						&& tempString.contains("#")) {
					int i = 0;
					// 按下标提取字符串,通过substring方法截取需要的数据.

					String EnumName = tempString.substring(i, i + 10).trim();
					String EnumValue = tempString.substring(i + 12).trim();
					// basetype=tempString.substring(i);

					if (EnumName.equals("USERTYPE")) {
						EnumName = "DataType";
					}
                                        //Element,添加节点,把截取到的数据添加到节点属性里.
					node = getroot.addElement("node").addAttribute("name",
							EnumValue).addAttribute("type", EnumName)
							.addAttribute("id", "1").addAttribute("basetype",
									"");

					if (node.attribute("basetype").getValue().equals("QUEUE")) {
						node.getParent().remove(node);
					}

				}
				// case 2
				else if (tempString.startsWith(str)
						&& !tempString.contains("#")
						&& !tempString.startsWith("   ")
						&& !tempString.contains("USERTYPEVERSION")
						&& !tempString.contains("ENDUSERTYPE")) {

					System.out.println(tempString);
					basetype = tempString.trim();
					System.out.println(basetype);
                                        //截取的属性,按自已的要求改名
					if (basetype.equals("STRING")) {
						basetype = "String";
					} else if (basetype.equals("INT")) {
						basetype = "Int";
					} else if (basetype.equals("DATE")) {
						basetype = "Date";
					} else if (basetype.equals("TIME")) {
						basetype = "Time";
					} else if (basetype.equals("REAL")) {
						basetype = "Double";
					} else if (basetype.equals("ENUM")) {
						basetype = "Enum";
					} else if (basetype.equals("QUEUE")) {
						basetype = "QUEUE";

					}
                                        //重新给该属性赋新的值.
					node.attribute("basetype").setValue(basetype);
					if (node.attribute("basetype").getValue().equals("QUEUE")) {
						node.getParent().remove(node);
					}

					System.out.println(node.asXML());
				} else if (tempString.trim().startsWith("TYPEREFERENCETYPE")) {
					int i = 0;
					int nodeid = 0;
					++nodeid;
					String dataParentName = tempString.substring(i).trim();

					if (dataParentName.equals("TYPEREFERENCETYPE")) {
						dataParentName = "DataTypeRelationItem";

					}
					itemtype = tempString.substring(i).trim();
					if (itemtype.equals("TYPEREFERENCETYPE DATASET")) {
						itemtype = "tablefield";
					} else if (itemtype.equals("TYPEREFERENCETYPE EXTERNFIXED")) {
						itemtype = "fixedvalue";
					}

					Element reltion = node.addElement("node").addAttribute(
							"name", "Relation").addAttribute("type",
							"DataTypeRelation");

					String name = node.attribute("name").getValue();
					// String
					// childrentablevalue=nodechildren.attribute("value").getValue();

					elementtion = reltion.addElement("node").addAttribute(
							"name", "").addAttribute("id",
							new Integer(nodeid).toString()).addAttribute(
							"type", "DataTypeRelationItem").addAttribute(
							"relationtype", itemtype);
					System.out.println(node.asXML());

				}

			}

			reader.close();
			return "成功";

		} catch (IOException e) {
			e.printStackTrace();
			return e.toString();
		} finally {

			if (reader != null) {
				DocumentOperator.saveDocument(filexml, document);
			}

		}

	}

上面这段代码有些雍容,管它呢先实现功能就很不错了,呵呵.这方法实现起来并不是最麻烦,在开发过程中.下面那方法才是我碰到最郁闷的….同时也认为是该小项目中最麻烦的地方.

原因:上面那方法转换之后.数据并不是很完美的,还需要处理,删除多余的信息,下面就是为该功能做出了贡献- -.

public String DeleteNode(String filexml) throws DocumentException,
			IOException, XmlPullParserException {

		Document document = DocumentOperator.getDocument(filexml);

		Element getroot = document.getRootElement();
               //在删除过程中.会删掉最后那个父节点root.所以新建一个root结尾的节点.
		Document docNew = DocumentHelper.parseText("");
		Element rootNew = docNew.getRootElement();// 定义一个新的root节点,并获取它.
		Element result;

		result = rootNew;
		for (Iterator iterator = getroot.elementIterator(); iterator.hasNext();) {
			Element ele = (Element) iterator.next();

			Element eleProperties = ele.element("node");

			if (eleProperties.attributeValue("name").equals("Name")) {
				result = eleProperties.getParent();

				if (result != rootNew)
					rootNew.add(result.detach());  //把多余的删余后,留下的信息添加到有用的节点里,这需要用detach分离
				// System.out.println(rootNew.asXML());

			} else {

				result.add(eleProperties.detach());//还是分离...

			}

		}

		DocumentOperator.saveDocument(filexml, rootNew);
		return rootNew.asXML();

	}

个人认为,这方法的难点在于新建节点上没有想到..及之类没用过detach方法.不知道他具体是什么功能.,开始用createCopy方法可以使现.但还不是最完美的..
detach:用于将节点分离,并会自动删除原有的节点及父节点.(分离后不在原父节点里情况下.)
createCopy:将需要的节点信息复制一份到目标节点里.并保留原有信息.

xml文件生成好了之后,还需要为他们的ID值配对.这样,访问就有关联数据了,方法很简单.不多解释了….

public String UpdateTreeFieldId(String filexml, int number) {

		try {
			Document doc = DocumentOperator.getDocument(filexml);
                        // 这里使用了Xpath(不知是不是这么叫),直接指定节点位置
			List list = doc.selectNodes("root/node/node/node");
			if (number < 0) {
				return "";
			}//number传入ID值.并通过递增写入xml文件
			int id = number;
			for (Iterator it = list.listIterator(); it.hasNext();) {

				Element ele = (Element) it.next();
				if (ele.attributeValue("type").equals("Field")) {

					ele.attribute("id").setValue(new Integer(++id).toString());

				}

			}

			DocumentOperator.saveDocument(filexml, doc);
		} catch (Exception e) {
		}

		return "";
	}

完整代码太多了.把主要功能分享出来.小小的变动还是看自已的条件去变动.
通过个小项目的锻练,对dom4j熟悉程度又进一步加深了.哈哈

删除xml指定的节点信息

Licream — Sun, 15 Aug 2010 06:44:03 +0000

之前做了更新功能，必然就有删除功能哈，实现起来非常简单，跟更新差不多．只是调用的方法不一样而已

还是一样先读取文件document = sa.read(new File(tablePath));
获得父节点信息我们下一下要通过父节点来删除子节点的信息．
Element root = document.getRootElement();
指定要删除的节点ＩＤ，ＩＤ值通过前台传值．
Element element = (Element) document.selectSingleNode("/root/node[@id='" + id + "']");
最后就是再此写入数据更新一下．．．呵呵
OutputFormat format = OutputFormat.createPrettyPrint(); XMLWriter writer = new XMLWriter(new FileOutputStream(tablePath),format); writer.write(document); writer.close(); return element.asXML();
是不是很简单哈，就这么点代码就完成了，指定详细删除的节点，还不需要遍历．省代码又省内存．是不是呢．

通过右键添加tree节点,并写入到数据到xml文件

Licream — Wed, 11 Aug 2010 09:10:33 +0000

昨天到现在.一直在折腾那个右键菜单来创建一个节点问题,可谓几经波折现在终于给搞定了,这把我鸡动的得先贴出来给大家分享下,也供自已以后备用复习用用:).

1.定义右键菜单功能
//定义右键菜单项 private function addContextMenuTables():void{ var t_tables:ContextMenu=new ContextMenu(); var M_openNewWindow:ContextMenuItem = new ContextMenuItem("Open New Windows"); var M_Tables:ContextMenuItem = new ContextMenuItem("New Table"); var M_Export:ContextMenuItem=new ContextMenuItem("Export"); var M_Compile:ContextMenuItem=new ContextMenuItem("Compile"); var M_Find:ContextMenuItem=new ContextMenuItem("Find"); var M_Addins:ContextMenuItem=new ContextMenuItem('Add-ins'); var M_Refresh:ContextMenuItem=new ContextMenuItem("Refresh"); //new Table的事件,newTableEvent是事件的方法 M_Tables.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,newTableEvent); t_tables.customItems.push(M_Tables); t_tables.customItems.push(M_openNewWindow); t_tables.customItems.push(M_Export); t_tables.customItems.push(M_Compile); t_tables.customItems.push(M_Find); t_tables.customItems.push(M_Addins); t_tables.customItems.push(M_Refresh); t_tables.hideBuiltInItems(); tree.contextMenu=t_tables; }


//newTable事件的方法

private function newTableEvent(event:Event):void

			{
			try{

                                //该DialogTextInput是一个组件文件.通过addElement方法打开该组件.

				var dialogTextInput:DialogTextInput = new DialogTextInput();

					this.addElement(dialogTextInput);

}catch(e:Error){ Alert.show(e.message); } }
//调用java远程的方法,createTableXmlFile()该方法是创建一个new Table.参数为table名称.
public function newTableOK(tablename:String):void { addTableXml.createTableXMLFile(tablename); }

CreateTableXmlFile方法代码.
public String createTableXMLFile(String tablename) throws DocumentException { Document document = null; SAXReader reader = new SAXReader(); String xmlpath = "E:\\EclipseProject\\ReadXml\\dataxml\\Tables.xml";


		document = reader.read(new File(xmlpath));
		Element getroot = document.getRootElement();
		GetId getId = new GetId();
		/** 建立document对象 */

		// document = DocumentHelper.createDocument();
		/** 加入第一个node节点 */

		Element nodeElement = getroot.addElement("node");
		if (tablename == "") {

			return "-1";

		} else {

			nodeElement.addAttribute("name", tablename).addAttribute("type",

					"Table").addAttribute("id", getId.getId());
			/** 添加node子节点fields */

			Element fields = nodeElement.addElement("node").addAttribute(

					"name", "Fields").addAttribute("type", "Fields")

					.addAttribute("id", "1");

			fields.addAttribute("name", "Fields")

					.addAttribute("type", "Fields").addAttribute("id", "2");

			Element itemid = fields.addElement("node").addAttribute("name",

					"ItemId").addAttribute("type", "Field").addAttribute("id",

					"3");

			Element itemName = fields.addElement("node").addAttribute("name",

					"ItemName").addAttribute("type", "Field").addAttribute(

					"id", "4");

			Element itemGroup = fields.addElement("node").addAttribute("name",

					"ItemGroup").addAttribute("type", "Field").addAttribute(

					"id", "5");
			/** 添加node子节点FieldGroup */

			Element fieldsGroups = nodeElement.addElement("node").addAttribute(

					"name", "FieldGroups").addAttribute("type", "FieldGroups")

					.addAttribute("id", "6");

			fieldsGroups.addAttribute("name", "Fields").addAttribute("type",

					"Fields").addAttribute("id", "6");

			Element autoReport = fieldsGroups.addElement("node").addAttribute(

					"name", "AutoReport").addAttribute("type", "FieldGroup")

					.addAttribute("id", "7");

			Element itemidReport = autoReport.addElement("node").addAttribute(

					"name", "ItemId").addAttribute("type", "FieldGroupItem")

					.addAttribute("id", "8");

			Element itemNameReport = autoReport.addElement("node")

					.addAttribute("name", "ItemName").addAttribute("type",

							"FieldGroupItem").addAttribute("id", "9");

			Element itemGroupReport = autoReport.addElement("node")

					.addAttribute("name", "ItemGroup").addAttribute("type",

							"FieldGroupItem").addAttribute("id", "10");

			Element configurReport = autoReport.addElement("node")

					.addAttribute("name", "Configurable").addAttribute("type",

							"FieldGroupItem").addAttribute("id", "11");

			Element autoLookup = fieldsGroups.addElement("node").addAttribute(

					"name", "AutoReport").addAttribute("type", "FieldGroup")

					.addAttribute("id", "12");

			Element itemidLookup = autoLookup.addElement("node").addAttribute(

					"name", "ItemId").addAttribute("type", "FieldGroupItem")

					.addAttribute("id", "13");

			Element itemNameLookup = autoLookup.addElement("node")

					.addAttribute("name", "ItemName").addAttribute("type",

							"FieldGroupItem").addAttribute("id", "14");

			Element bom = fieldsGroups.addElement("node").addAttribute("name",

					"AutoReport").addAttribute("type", "FieldGroup")

					.addAttribute("id", "15");
			/*** 添加node子节点Indexes */

			Element indexes = nodeElement.addElement("node").addAttribute(

					"name", "Indexes").addAttribute("type", "Indexes")

					.addAttribute("id", "16");

			;
			Element itemIdx = indexes.addElement("node").addAttribute("name",

					"ItemIdx").addAttribute("type", "Index").addAttribute("id",

					"17");

			Element itemIdIndex = itemIdx.addElement("node").addAttribute(

					"name", "ItemId").addAttribute("type", "IndexItem")

					.addAttribute("id", "18");

			/** 添加node子节点Relations */

			Element relations = nodeElement.addElement("node").addAttribute(

					"name", "Relactions").addAttribute("type", "Relations")

					.addAttribute("id", "19");

			Element itemConfig = relations.addElement("node").addAttribute(

					"name", "ItemConfig").addAttribute("type", "Relation")

					.addAttribute("id", "20");

			Element id1 = itemIdx.addElement("node").addAttribute("name", "1")

					.addAttribute("type", "RelactionItem").addAttribute("id",

							"21");

			Element id2 = indexes.addElement("node").addAttribute("name",

					"ItemIdx").addAttribute("type", "RelactionItem")

					.addAttribute("id", "22");

		}

		try {
			/** 将document中的内容写入文件中 */

			/** 美化xml标签 */

			OutputFormat format = OutputFormat.createPrettyPrint();

/** 实例化XMLWriter,利用FileWriter指定文件写入 */ XMLWriter writer = new XMLWriter(new FileWriter(xmlpath), format); writer.write(document); writer.close(); return nodeElement.asXML(); } catch (Exception ex) { ex.printStackTrace(); return "-1"; } }

接下来把DialogTextInput组件的事件实现一下,通过上面的addElement方法调用该组件.
简单的定义了一个输入框和二个按钮

ReadXml是主模块,上面的flex代码都是在此文件里的.主要是需要调用newTableOK事件.通过输入框的值传入.
removeElement(this)是关闭本窗口的意思,开始为找关闭功能一直在点close之类的信息都没用.郁闷…
protected function btnOK_clickHandler(event:MouseEvent):void { try { (this.parentApplication as ReadXml).newTableOK(this.textTable.text); this.parentApplication.removeElement(this); } catch (error:Error) { Alert.show(error.toString()); } }

protected function btnCancel_clickHandler(event:MouseEvent):void { try { this.parentApplication.removeElement(this); } catch (error:ErrorEvent) { Alert.show(error.toString()); } }
还是这样说.完整的代码可去我googleSVN上面看看..本人初学者…很多代码没有优化额,望高手们多多指正.

使用Tree和DataGrid组件读取Xml文件

Licream — Mon, 09 Aug 2010 05:34:07 +0000

最近做了个小东西,使用了Tree和DataGrid组件,并通过xml文件定义好的结构在tree上显示节点和通过xml文件把数据显示在DataGrid上面.

我通过dom4j来读取xml文件.下面是我读取xml文件的代码
先插首歌曲听听

package gongqi.xml.service;

import java.io.File;
import java.util.Iterator;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.flex.remoting.RemotingInclude;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RemotingDestination(channels = { "my-amf" })
@Transactional
public class ReaderXml {

	@RemotingInclude
	public String gReadXml(String filexml) {
		SAXReader reader = new SAXReader();
		String xml = "";
		try {
			Document doc = reader.read(new File(filexml));
			Element elements = doc.getRootElement();

			for (Iterator it = elements.elementIterator(); it.hasNext();) {
				Element element = (Element) it.next();
				xml += element.asXML();
			}
		} catch (DocumentException e) {
			e.printStackTrace();
		}
		return xml;

	}

}

这是创建xml文件代码有点臃肿.呵呵:

package gongqi.xml.service;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.flex.remoting.RemotingInclude;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RemotingDestination(channels = { "my-amf" })
@Transactional
public class CreateXml {

	/**
	 * 创建xml文件
	 *
	 * @param filexml
	 * @return
	 * @throws IOException
	 */
	@RemotingInclude
	public String createXMLFile(String filename) {

		/** 建立document对象 */
		Document document = DocumentHelper.createDocument();
		/** 建立XML文档的根root */
		Element root = document.addElement("root");

		/** 加入一行注释 */
		root.addComment("这是一个表结构");

		/** 加入第一个node节点 */
		Element nodeElement = root.addElement("node");
		nodeElement.addAttribute("name", "newtable").addAttribute("type",
				"Table").addAttribute("id", "1");

		/** 添加node子节点fields */
		Element fields = nodeElement.addElement("node").addAttribute("name",
				"Fields").addAttribute("type", "Fields")
				.addAttribute("id", "2");
		fields.addAttribute("name", "Fields").addAttribute("type", "Fields")
				.addAttribute("id", "2");
		Element itemid = fields.addElement("node").addAttribute("name",
				"ItemId").addAttribute("type", "Field").addAttribute("id", "3");
		Element itemName = fields.addElement("node").addAttribute("name",
				"ItemName").addAttribute("type", "Field").addAttribute("id",
				"4");
		Element itemGroup = fields.addElement("node").addAttribute("name",
				"ItemGroup").addAttribute("type", "Field").addAttribute("id",
				"5");

		/** 添加node子节点FieldGroup */
		Element fieldsGroups = nodeElement.addElement("node").addAttribute(
				"name", "FieldGroups").addAttribute("type", "FieldGroups")
				.addAttribute("id", "6");
		fieldsGroups.addAttribute("name", "Fields").addAttribute("type",
				"Fields").addAttribute("id", "6");
		Element autoReport = fieldsGroups.addElement("node").addAttribute(
				"name", "AutoReport").addAttribute("type", "FieldGroup")
				.addAttribute("id", "7");
		Element itemidReport = autoReport.addElement("node").addAttribute(
				"name", "ItemId").addAttribute("type", "FieldGroupItem")
				.addAttribute("id", "8");
		Element itemNameReport = autoReport.addElement("node").addAttribute(
				"name", "ItemName").addAttribute("type", "FieldGroupItem")
				.addAttribute("id", "9");
		Element itemGroupReport = autoReport.addElement("node").addAttribute(
				"name", "ItemGroup").addAttribute("type", "FieldGroupItem")
				.addAttribute("id", "10");
		Element configurReport = autoReport.addElement("node").addAttribute(
				"name", "Configurable").addAttribute("type", "FieldGroupItem")
				.addAttribute("id", "11");
		Element autoLookup = fieldsGroups.addElement("node").addAttribute(
				"name", "AutoReport").addAttribute("type", "FieldGroup")
				.addAttribute("id", "12");
		Element itemidLookup = autoLookup.addElement("node").addAttribute(
				"name", "ItemId").addAttribute("type", "FieldGroupItem")
				.addAttribute("id", "13");
		Element itemNameLookup = autoLookup.addElement("node").addAttribute(
				"name", "ItemName").addAttribute("type", "FieldGroupItem")
				.addAttribute("id", "14");
		Element bom = fieldsGroups.addElement("node").addAttribute("name",
				"AutoReport").addAttribute("type", "FieldGroup").addAttribute(
				"id", "15");

		/*** 添加node子节点Indexes */
		Element indexes = nodeElement.addElement("node").addAttribute("name",
				"Indexes").addAttribute("type", "Indexes").addAttribute("id",
				"16");
		;

		Element itemIdx = indexes.addElement("node").addAttribute("name",
				"ItemIdx").addAttribute("type", "Index").addAttribute("id",
				"17");
		Element itemIdIndex = itemIdx.addElement("node").addAttribute("name",
				"ItemId").addAttribute("type", "IndexItem").addAttribute("id",
				"18");
		/** 添加node子节点Relations */
		Element relations = nodeElement.addElement("node").addAttribute("name",
				"Relactions").addAttribute("type", "Relations").addAttribute(
				"id", "19");
		Element itemConfig = relations.addElement("node").addAttribute("name",
				"ItemConfig").addAttribute("type", "Relation").addAttribute(
				"id", "20");
		Element id1 = itemIdx.addElement("node").addAttribute("name", "1")
				.addAttribute("type", "RelactionItem").addAttribute("id", "21");
		Element id2 = indexes.addElement("node")
				.addAttribute("name", "ItemIdx").addAttribute("type",
						"RelactionItem").addAttribute("id", "22");

		try {
			/** 将document中的内容写入文件中 */
			XMLWriter writer = new XMLWriter(new FileWriter(new File(filename)));
			writer.write(document);
			writer.close();

		} catch (Exception ex) {

			ex.printStackTrace();
		}

		return document.asXML();

	}
}

切换到前台,通过BlazeDS远程生成服务,并调用上面的方法.很简单的.
先需要声明service服务

通过HTTPService访问远程xml文件,并解析为xml形式在readerxml1_resultHandler 方法里实现以xmllist类型显示 gotxml=XMLList(event.result.toString());

//调用远程方法读取xml文件.
serviceReadXml.gReadXml(“E:/工作资源/erp/Gongqi_XML/got/GOT.xml”);

//把数据绑定到Tree组件上面
dataProvider=”{gotxml}”

自定义右键菜单.


private function showTables():void{

				var t_tables:ContextMenu=new ContextMenu();

				var M_openNewWindow:ContextMenuItem = new ContextMenuItem("Open New Windows");
				var M_Tables:ContextMenuItem = new ContextMenuItem("New Table");
				var M_Export:ContextMenuItem=new ContextMenuItem("Export");
				var M_Compile:ContextMenuItem=new ContextMenuItem("Compile");
				var M_Find:ContextMenuItem=new ContextMenuItem("Find");
				var M_Addins:ContextMenuItem=new ContextMenuItem('Add-ins');
				var M_Refresh:ContextMenuItem=new ContextMenuItem("Refresh");

				M_Tables.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT,newTableEvent);

				t_tables.customItems.push(M_Tables);
				t_tables.customItems.push(M_openNewWindow);
				t_tables.customItems.push(M_Export);
				t_tables.customItems.push(M_Compile);
				t_tables.customItems.push(M_Find);
				t_tables.customItems.push(M_Addins);
				t_tables.customItems.push(M_Refresh);
				t_tables.hideBuiltInItems();
				tree.contextMenu=t_tables;

			}
private function newTableEvent(event:Event):void{

				try{
					newTable.createXMLFile("E:/Tables.xml");
					Alert.show(".......");

				}catch(io:IOError){
					Alert.show(io.message);
				}
			}

根据节点要显示的功能不同及菜单项不同.我分别进行了一些判断.

public function tree1_changeHandler(event):void{

				//注意:如果在父节点加入子节点xml,再不变更节点目录下,不能使用统一service ID,重新定义一个srevice ID来执行远程方法
				if(tree.selectedItem.@type=='Tables'){

					tableReadXml.gReadXml("E:/工作资源/erp/Gongqi_XML/got/datadictionary/Tables.xml");
					showTables();

				}else if(tree.selectedItem.@type=='Enums'){

					tableReadXml.gReadXml("E:/工作资源/erp/Gongqi_XML/got/datadictionary/Enums.xml");

				}else if(tree.selectedItem.@type=='ExtendedDataTypes'){

					tableReadXml.gReadXml("E:/工作资源/erp/Gongqi_XML/got/datadictionary/ExtendedDataTypes.xml");

				}else if(tree.selectedItem.@type=='Table'){					

					srvtable.send();

				}else if(tree.selectedItem.@type=='Field'){

					tablefield.send();
				}else if(tree.selectedItem.@type=='FieldGroup'){

					this.tablefieldgroup.send();

				}else if(tree.selectedItem.@type=='Index' ){

					this.tableindex.send();

				}else if(tree.selectedItem.@type=='Relation'){

					this.tablerelation.send();

				}else if(tree.selectedItem.@type=='Enum' ){

					this.enum.send();

				}else if(tree.selectedItem.@type=='EnumItem' ){

					this.enumitem.send();

				}else if(tree.selectedItem.@type=='RelationItem' ){

					this.extendeddatatypeitem.send();

				}else if(tree.selectedItem.@type=='ExtendedDataType' ){

					this.extendeddatatype.send();

				}else if(tree.selectedItem.@type=='RelationItem' ){

					this.tablerelationitem.send();

				}else if(tree.selectedItem.@type=='GOT'){	

					showGotMenu();			

				}else if(tree.selectedItem.@type=='DataDictionary'){
					showDataDictionary();

				}
			}

//在tree节点上添加子节点的xml文件.需将selecteditem转换为xml类型;

protected function tableReadXml_resultHandler(event:ResultEvent):void
			{
				//将所有xml文件都显示出来,使用appendchild添加到子节点上
				tablesxml=XMLList(event.result.toString());
				enumsxml=XMLList(event.result.toString());
				extendsDataTypexml=XMLList(event.result.toString());
				var xml:XML=tree.selectedItem as XML;
				xml.appendChild(tablesxml);
			}

要显示每个节点的属性即在DataGrid组件上显示数据.我们需要先定义一个全局的变量为XML类型;
private var pro:XML;
远程访问文件后进行绑定在DataGrid组件上面

pro=XML(event.result);
dgpro.dataProvider =pro.child(“node”).children();//node节点下所有属性

表达能力有限..这些完整代码我上传到google SVN上面了.有兴趣的可以去看看:http://code.google.com/p/licreamflexspringhibernate/source/list

整理分析项目流程

licream — Fri, 30 Jul 2010 04:57:49 +0000

上午用了些时间整理了一下最近使用的技术,比不上专业人员.粗略的说了下自已认识.
本来是用PPT通过google直接共享在这的.可惜被强奸了啊..我们是看不到的..

图简单的画了下.也不知道是不是正确的,我是按照自已的思路完成:)

Hibernate注解

通过注解,我们可以完成以前的xml文件配置功能,这里说下 hibernate注解,目前我使用主要是在实体类中定义表结构.对应表结构或创建表结构.进行自动装配Bean. 使用注解包需采用javax.persistence.*; 下面的注解，而不是org.hibernate.annotation.*;虽然这二个包功能是一样.为了那传说中的jpa规范吧.

Entity实体

@Entity:将一个类声明为一个实体bean

@Table:声明该实体bean映射指定的表上面二个用在类的上面

@Column:注解声明了属性到列的映射

@Id:声明该实体bean的标识属性,对应表主键

@GeneratedValue :注解声明了主键的生成策略常用的表映射有这些,其它需要的时侯查查API文档如果注解里面有value属性则可以省略写直接赋值就可以,例:@Talbe(value=“”)==@Table(“”) 这些注解将替代了以前hbm.xml形式来映射

Dao

子类继承hibernateDaoSupport,重写sessionFactory,并用注解@Resource注入,这样完成了dao与sessonfactory之间的依赖注入. @Repository:用于标示数据访问层(持久层).定义在class类上面各层之间注解:这些注解只能用法实现类,不可用在接口类

@Component:可装载组件(泛型模形)

@Repository:持久层组件

@Service:服务层组件
@Controller:控制层组件如果想在一个类中获得文件可以通过在xml配置这个类的某个属性。在注解的方式中，可以使用@Value来指定这个文件。例:@Value(“/WEB-INF/database.properties”)

注解说明

@Resource注解所提供名字相匹配的“bean name（bean名字）”的Spring管理对象会被注入.不指定名称则采用该类名为bean name. 等同于 sessionFactory与dao层及service层的注入用该注解完全可不用在配置文件里写任何bean信息

Service

通过接口方法来调用持久层的方法,声明持久层接口用注解为他们之间进行依赖注入.

@Service:表示该类为服务类.用在 class类上面

@Transactional:需要事务管理的地方则加上,类的class和类的方法体上都可以加.方法体优先于类的class执行.注解要是写到接口方法上，要使用cglib代理，这时注解事物就失效了，为了保持兼容注解最好都写到实现类方法上,一般来说,将事务定位在业务层，这是非常务实的做法, 有二个常用属性(readOnly = false, rollbackFor = DataAccessException.class)只读关闭，遇到DataAccessException异常回滚

Web.xml

添加spring,BlazeDS,Log4j相应的过滤器注册注意该文件的标签顺序,否则会出错.

Spring在flex的作用

MessageBroker 是 SBI 的一个组件，它的职责是处理 Flex 远程调用请求。MessageBroker 由 Spring 容器进行管理而不是由 BlazeDS。在 Web.xml 中添加 DispatcherServlet 允许 Spring 自行管理 MessageBroker。

注册spring容器


		Spring MVC Dispatcher Servlet
		org.springframework.web.servlet.DispatcherServlet
		
			contextConfigLocation
			/WEB-INF/config/application-config.xml
		
		1



		Spring MVC Dispatcher Servlet
		/messagebroker/*

利用spring把系统默认的BlazeDS的MessageBrokerServlet代理了
spring容器注册,并指定applicaion-config.xml配置文件路径.
第二条代码指定请求路径.

BlazeDS介绍

BlazeDS 是 Adobe Live-Cycle Service 的免费开源版本，它使用 AMF 二进制协议通过 AMF 管道构建了 Flex 和 Spring 进行数据通信的桥梁。BlazeDS 可以实现 Flex 对 Java 对象的远程调用。BlazeDS 可以部署运行在大多数 Web 应用服务器上，如 Tomcat、Websphere、JBoss 以及 Weblogic。

BlazeDS服务注册


RDSDispatchServlet
RDSDispatchServlet
flex.rds.server.servlet.FrontEndServlet

messageBrokerId
_messageBroker


useAppserverSecurity
false

10



RDSDispatchServlet
/CFIDE/main/ide.cfm

Log4j注册


log4jConfigLocation
/WEB-INF/log4j.properties


log4jRefreshInterval
1000



org.springframework.web.util.Log4jConfigListener

Application配置
首先配置flex,hibernate,等需要的命名空间.

利用注解方式类配置hibernate,sessionFactory,并指定数据源.配置实体类路径,利用annotatedClasses自动扫描访实体类,与指定hbm.xml意义相同.优点是省了xml文件.
目前annotatedClasses还不能通过包名来自动扫描下面的注解类.需要手动一个一个的添加.或采用正则表达式方式添加.





entity.UserInfo

我们还需要扫描spring相关的注解功能.配置自动扫描代码:

自动扫描dao包里面的类.需要扫描其它包则修改为相应的包名即可.

Flex介绍

Flex 的通信协议主要有三种：HttpService、WebService 和 RemoteObject。RomoteObject 协议作为 Flex 提供的最快的通信方式，通过集成 BlazeDS，利用 AMF（Action Message Format）二进制协议使得 Flex 前端能轻松与 Java EE 后端进行数据交互，它是 Flex 集成 Spring 的首选通信协议。

配置flex信息
配置请求通道,通道定义在service-config.xml,有几种通道.把我们需要的引入出来,使用多种用短号分开






常用的注解有:
@RemotingDestination :定义在类上面
@RemotingInclude:定义在方法体上面

顺手测试下音乐功能:

通过注解实现注册功能Flex

Licream — Tue, 20 Jul 2010 01:09:14 +0000

１. 利用Eclipse新建一个Flex项目名叫：FBS

按步一下并按照下图配置信息，再点完成．

２. 切换到java ee视图环境下编写java类,后台代码

在src目录下分别新建三个包:entity,dao,service.

在entity包里新建一个UserInfo的实体类

在方法体内写三个变量．Id,name,pass. 按shift+alt+s键并为他们生成set,get方法．

在类上面定义注解:@Entity及@table

在变量的get方法上面(除了主键)添加@colume

package entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table   //定义表名，不指定名则默认为该类名
public class UserInfo {
	public int Id;
	public String Name;
	public String Pass;
	@Id //主键ID
	@GeneratedValue //自动增长属性
	public int getId() {
		return Id;
	}
	public void setId(int id) {
		Id = id;
	}
	@Column //定义一个列属性
	public String getName() {
		return Name;
	}
	public void setName(String name) {
		Name = name;
	}
	@Column
	public String getPass() {
		return Pass;
	}
	public void setPass(String pass) {
		Pass = pass;
	}

}

上面是完整的UserInfo代码.该类我们已经写好了,现在定义一个Dao,我们采用HibernateDaoSupport来实现.我们先写一个DAO的基类.在里面自动注入sessionFactory.通过子类来继承它,则子类自动注入到sessionFactory的实现.

这是DAO基类代码:

package dao;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

public class SuperDao extends HibernateDaoSupport{

	@Resource(name = "sessionFactory") //该注解意思是自动注入,指定名称为sessionFactory,要和xml里的名称一样
	public void setSessionFactoryOverride(SessionFactory sessionFactory) {
		super.setSessionFactory(sessionFactory);
	}

}

接下来我们声明一个UserInfoDao的接口.在里面写入要实现的方法

这是userInfoDao接口代码:

 package dao;

import java.util.List;

import entity.UserInfo;

public interface UserInfoDao {
	public void addUserInfo(UserInfo user);
	public List findAll();
}

建创一个UserInfoDaoImpl类来实现该接口的方法.并继续SuperDao基类.

这是UserInfoDaoImpl实现方法的代码(另个方法没去实现.添加功能通过了,其它功能以后再添加),实现了添加方法

 package dao;

import java.util.List;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import entity.UserInfo;
@Repository //表示持久层
public class UserInfoDaoImpl extends SuperDao implements UserInfoDao{

	@Override
	public void addUserInfo(UserInfo user) {
		this.getHibernateTemplate().save(user);

	}

	@Override
	public List findAll() {
		// TODO Auto-generated method stub
		return null;
	}

}

现在我们需要创建服务类.与dao层类似.也是需要先定义一个接口.再实现接口的方法.再通过UserDao来调用持久层的方法.

这是UserInfoServiceImpl类代码:

 package service;

import java.util.List;

import javax.annotation.Resource;
import javax.persistence.TableGenerator;

import org.springframework.flex.remoting.RemotingDestination;
import org.springframework.flex.remoting.RemotingInclude;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import dao.UserInfoDao;
import entity.UserInfo;

@Service("UserInfoService")
// 表示该类为service层
@RemotingDestination(channels = { "my-amf" })
@Transactional
// 调用事务
public class UserInfoServiceImpl implements UserInfoService {

	@Resource
	UserInfoDao userInfoDao; // 声明UserInfoDao

	@Override
	@RemotingInclude
	public void addUserInfo(UserInfo user) {
		userInfoDao.addUserInfo(user);

	}

	@Override
	@RemotingInclude
	public List findAll() {
		// TODO Auto-generated method stub
		return null;
	}

}

接下来.在src目录下创建一个来与数据库连接的数据源,hibernate.cfg.xml.可通过工具来生成.

以下是该xml代码.其中数据库名称,用户名,密码需要修改.使用mysql数据库.

 


	
		org.hibernate.dialect.MySQLDialect
		com.mysql.jdbc.Driver
		jdbc:mysql://localhost:3306/hibernate
		root
		lds7617
		create
		true
		true
		thread

		
		20
		
		5
		
		120
		
		100
		
		120
		
		2
		
		true

接着在hibernateconfig.xml文件通过sessionFactory来注入数据源.并配置事务处理管理器

 


	
	
		
		
		
		
			
				entity.UserInfo

再找到daoconfig.xml和serviceconfig.xml配置文件修改相应的包名.daoconfig.xml对应的是dao包的路径,serviceconfig.xml对应的是service包的路径.

向flexconfig.xml配置信息添加启动注解支持及路径访问配置.这是flexconfig.xml代码.

对工程进行编译一次.确认没有错误.

接下来我们切换到flash视图环境下编写mxml文件.通过前台来调用后台的业务.

简单的设计下界面

对注册按钮右键点击生成服务调用功能:

选择BlazeDS服务.并钩选不需要密码.点下一步.会出现该错误.

解决方法:找到该工程目录下. .flexProperties文件.打开他.修改serverContextRoot=”/WebRoot”参数为项目名serverContextRoot=”/FBS” .修改完成生记得刷新一下工程.才能生效.

下一步可以看到我们通过注解公开的bean.

钩选我们要使用的.UserInfoService,并完成

再右键注册按钮来生成服务调用,刚才的步骤是新建服务,现在是用生成好的服务利用组件来调用它们.

我们选择addUserInfo方法.

对生成好的事件进行修改:

var userInfoFlex:UserInfo=new UserInfo();
				userInfoFlex.Name=txtname.text;
				userInfoFlex.pass=txtpass.text;
				addUserInfoResult.token = userInfoService.addUserInfo(userInfoFlex);

还需要为该事件定义路径:

修改如下代码:

这样算简单的配置完成了.如果发现flex_src目录下有文件错误.一般都是因为有重复的代码造成的.删除多余的就可以了.

删除有红色X的方法体.他们是因为有重复的方法了

再重新编译一次..

右键主模块FBS.mxml 运行

如果发现该文件出现404错误,需为工程设置路径.右键工程.–>属性àflex构建路径.右下角修改为: http://localhost:8080/FBS/

结果发现有空值针异常.null.

经过检验,发现在UserInfoServiceImpl里的UserInfoDao没有注入给UserInfoServiceImpl.所以会引发这问题.解决的方法是在UserInfoDao上面添加

 @Resource
 UserInfoDao userInfoDao; //声明UserInfoDao

成功添加数据:

一个简单的注册功能完成了

更新flex+spring+hibernate通过注解改良实现

Licream — Tue, 20 Jul 2010 00:43:43 +0000

看到官方网上的视频做的例子是通过注解来实现.减少了配置文件代码.我觉得这功能非常不错,经过自已一些测试实验.最终做出点像样的东西了.0 0.额.
下载了官方最新的BlazeDS.war.自已在里面添加了一些hibernate核心包及注解包.版本为.hbiernate3.spring3.flex4.添加了几个配置5个配置文件.和一些必需的相关代码..
我现在一一的贴上来吧:

application-config.xml,主要是引入其它配置文件信息.

daoconfig.xml:扫描Dao层包里有注解的类.

serviceconfig.xml与dao层的配置文件一样.是扫描service层的

flexconfig.xml 对flex一些信息处理.

hibernateconfig.xml:配置数据源及sessionFactory和事务处理.




	
	
		
		
		
		
			
				entity.UserInfo

配置web.xml代码为:





	FBS
	BlazeDS Application

	
		flex.class.path
		/WEB-INF/flex/hotfixes,/WEB-INF/flex/jars
	

	
	
		flex.messaging.HttpFlexSession
	

	
		RDSDispatchServlet
		RDSDispatchServlet
		flex.rds.server.servlet.FrontEndServlet
		
			messageBrokerId
			_messageBroker
		
		
			useAppserverSecurity
			false
		
		10
	

	
	
		MessageBrokerServlet
		flex.messaging.MessageBrokerServlet
		
			services.configuration.file
			/WEB-INF/flex/services-config.xml
		
		
			flex.write.path
			/WEB-INF/flex
		
		1
	

	
		Spring MVC Dispatcher Servlet
		org.springframework.web.servlet.DispatcherServlet
		
			contextConfigLocation
			/WEB-INF/config/*-config.xml
		
		1
	

	
		RDSDispatchServlet
		/CFIDE/main/ide.cfm
	

	
		MessageBrokerServlet
		/messagebroker/*
	

	
	
		Spring MVC Dispatcher Servlet
		/messagebroker/*
	

	
		index.html
		index.htm

以上的代码基本是通用的.只需修改上面的路径就可以了.通过web.xml里面定义的过滤器来调用application-config.xml即可.
自已也修改了一份blazeds.war..添加了上面的信息..集成好了的.如果有需要的可以发我邮箱索要.因为20多M..上传到空间不忍心哈..

Flex+Spring整合详细流程绝对正常运行

Licream — Thu, 15 Jul 2010 18:44:41 +0000

经过二周反复的新建删除新建删除重复的工作.现在终于有点成果了.对flex不了解.用了这么长时间才把他们整合好了.哎..其间碰到各种问题,真是郁闷死. 先把flex+spring发上来吧.hibernate还没完美整合上来- -.

我用文档写好了.我就直接贴上来自已也算在这备份一次.HOHO

1. Flex +Spring整合方法

i. 准备工具Eclipse,BlazeDS,Spring,Tomcat.

1. 使用Eclipse3.5 +flex builder 4 pulgin+Spring3.0+Tomcat6.0+JDK6.0+ BlazeDS

2. 下载地址:

3. Flex Builder 4: http://www.adobe.com/

4. Eclipse: http://www.eclipse.org/downloads/

5. Spring3.0: http://www.springsource.org/download

6. Tomcat6.0: http://tomcat.apache.org/download-60.cgi

7. JDK6.0: http://java.sun.com/javase/downloads/index.jsp

2. 创建HelloWorld工程

i. 打开Eclipse,打开文件菜单,选择Flex项目.

4. 定义项目名称为HelloWorld.应用类型为j2ee web形式,远程服务选用BlazeDS(简洁又免费),我们是把flex+java项目整合在一个项目工程里面.所以要钩选:使用WTP创建java/flex组合项目.

6. 在目标运行时后面那按钮点开他新建一个Tomcat服务.选中Tomcat V6.0.然后完成.回到新建工程第二部,选择刚才建的tomcat服务名称.

8. 指定blazeDS文件路径.在输入文件夹名称修改为:WebRoot与内容文件夹同名.,这样就可以完成了工程的创建!

10. 补充下,我使用的blazeDS是最新版.自带很多JAR包及spring3.0包..还有web.xml.项目已经建完了,我们还需要配置一下.双击服务器.把我们刚新建的工程添加到tomcat模块里.点确定.

11.

12.

13. 再右键工程名打开属性: 在flex构建路径下的输出文件夹URL设置为:http://localhost:8080/项目名/.记得一定要在项目名后面加正斜杠.基本配置完成!

14.

15. 在项目WEB-INF目录下新建一个存放xml文件夹.主要用来存放spring,hibernate及其它扩展xml信息文件.方便管理而已,项目结构如下:

16.

17.

18. 复制下面代码到application-config.xml(该文件负责的功能是spring配置信息)

22. 复制下面代码到dispatchservlet-config.xml文件里面(该文件负责blazeDS远程公开服务.采用注解方式,优点是减少xml的配置信息.)

26. 现在我们建个java 类,命名为Test.

 	@Service("test")  	@RemotingDestination(channels={"my-amf"}) 	public class Test { 	@RemotingInclude 	public String say(String name){ 	return "欢迎加入"+name; 		}

31. 回到application-config.xml文件向里面添加这二条代码:

b) "test" />

32. 回到dispatchservlet-config.xml文件向里面添加这段代码:

1. "my-amf" />

ii.

33. 回到web.xml文件.把里面的

34. useAppserverSecurity

1. false 这样可以不用密码来有使用数据服务.

35. 记录修改配置文件路径.

i. contextConfigLocation

ii. /WEB-INF/config/*-config.xml

36. 运行之后不知为什么会提示没有flex-servlet.xml这个文件.那我就在web.xml同目录下新建一个好了哈.

37. 添加代码到该文件下:

41. 其实可以把另二个配置文件的信息都加到这里面来.我前面已经配置好了.所以这个就空在这.留个备用.呵呵,具体看不出web.xml哪条信息要读取这文件的.不知是不是系统定义的.

42. 用Tomcat启动项目后,切换到flash工程环境下.在数据服务标签下有个连接数据/服务功能.使用他我们可以用blazeds对后台进行通信,钩选不需要密码.点下一步会出现如下错误.

43. 解决的办法:找到工程目录下的.flexProperties文件.修改上下文配置(意思大概是这样吧) serverContextRoot="/WebRoot"修改为serverContextRoot="/HelloWorld".一定要改成项目名称.随后刷新工程.再连接数据服务.

44. 我们先来测试下能不能正常读到后右的数据.钩选要读取的信息.如多个类文件则会显示多个services配置信息名称.我们选中test.下面二条输入框为默认.

45.

46. 建好之后在数据服务标签栏上找到如下图标.来测试数据是否正常通信.

47.

48. 嗯,测试成功了.说明我们之前的配置信息是没有问题了.能正常跟后台通信了.

49. 接下来我们切换到flash视图环境下编辑mxml主文件.添加二个组件.一个输入框及文本组件.

50. 添加如下代码在非可视标签下<:fx:Declarations>

52. 接下来我们把数据绑定在组件上,最终代码如下.button纯属自已多余添加的可不看-..

53.

54.

浅谈组件映射

Licream — Tue, 04 May 2010 13:28:15 +0000

hibernate中的关联映射主要有三种:一对一,一对多(多对一),多对多.它们都可以分为单向和双向双种.
凡是双向关联必设mappedBy
一对一关联映射有两种:
一种是主键关联:限制两个数据表的主键使用相同的值
一种是外键关联:是一个外键和一个惟一关键字对应
一对一不产生新的字段而多对一会产生新的字段
多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一
一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多
也就是说一对多和多对一的映射策略是一样的，只是站的角度不同

ID生成策略及Session用法

Licream — Thu, 22 Apr 2010 04:48:40 +0000

看了点ID生成的xml配置和annotation配置,重点放在annotation上面.为了经后需要吧.在实体类里利用@GeneratedValue来的strategy属性对主键设置生成策略的类型.常用的就IDENTITY(ms sql,mysql)和SEQUENCE(oracle).配置联合主键得需要用到,@EmbeddedId.

@GeneratedValue(strategy=GenerationType.IDENTITY)

Session需要SessionFactory来产生和管理.通常只需要一个sessionfactory.

打开session有二种方法:

opensession:每次都是新的,需要手动关闭session.

getcurrentsession:从上下文找,如果有,用旧的,没有建新的,带自动关闭sesison.

对于自定义的hibernate配置xml可用configure(“hibernate.cfg.xml”)指定.

get:直接从数据库加载,不会延迟

load:返回的是代理对偈.等真正用到对像的内容时才发出sql语句.

无论是load还是get都会首先查找缓存(一级缓存),如果没有,才会去数据库查找.调用clear()方法可以强制清除session缓存.

调用flush()方法可以强制进行从内存到数年据库的同步,merge()用来合并数据.

实操中遇到Field ‘id’ doesn’t have a default value错误:在对ID设置好策略后ID也不自动递增.网上基本都是说修改my.ini.我没去试.后来我把表删表..就正常了- -!