BlogJava-Think in MyLife-文章分类-Frame

2007年标志设计趋势密码[转]

天边一片伴月星 — Thu, 08 Mar 2007 03:38:00 GMT

2007年标志设计趋势密码
2007 Logo Design Trends

2007年1月发表，1月24日由Quester中文翻译，原文链接：http://logoorange.com/logo-design.php

11 trends that will define Logo design in 2007

Everyone wants to set the curve when it comes to style. No one wants to design out of a book of trends, but nevertheless, they emerge.
Take a peek at the following 11 Logo design trends that we think will define the look of 2007.

11种趋势将定义2007年的Logo设计

每个设计师都想在某一风格成为流行前把握它。没有人愿意自己的设计和流行趋势脱节。但是无论如何，这些趋势总是会露出端倪。

让我们一同来窥探一下这11种我们认为的2007年标志设计的趋势密码。

1. Talk Boxes

This is an outgrowth of last year's trend, even though these boxes have been around a few years now.
We don't quite know who's doing the talking, but whoever it is, their bubble is popping up all over. This Logo symbolizes communication, whether it be from the company or between its customers. LifeLogger, for instance, uses a speech bubble with a smile in it to illustrate how users can communicate through them to friends. They continue the use of three-dimensional speech bubbles in creating avatars for their users, as illustrated to the right.
In this way, the idea of communication represents the person themselves, showing the importance of contact.

1. 对话泡泡

这是一种去年的流行风格的衍生，尽管这些泡泡已经玩了好几年了。
我们搞不懂是谁在说话，但管它是谁呢，反正满处都是冒的这些泡泡。这个符号象征着沟通，无论是来自企业还是他们的客户之间。LifeLogger（生活的记录者）网站，是一个例证，用泡泡和微笑符号来说话，表明用户可以用什么样的方式和他们的朋友来交流。他们继续使用立体的对话泡泡来为用户创造神话，就像右边那个泡泡。
在这里，沟通的想法代表这些人本身，想要展示接触的重要性。

2. Clouds

Everyone remembers a time when they laid on their back in the grass, staring at the clouds daydreaming or finding images in their puffs.
Clouds are a powerful Logo, conjuring imagery of dreams, creativity and playfulness. Sometimes clouds are combined with thought bubbles to invoke feelings of dreaminess. The clouds can be a 3D bubble or take on a flat feeling. Many of these cloud Logos represent new ideas, hence the thought bubble. Many "clouds" came from new businesses on the internet, certainly a place for dreamers. Some, also include imagery of the sun, which evokes a feeling of a new dawn.

2. 云状物

每个人都有那些仰面躺在草地上的时候，望着云朵发白日梦或者从腾云变换中寻找图案的记忆。
云状物是一个极有表现力的标志，凭空幻化意象，即有创造性，又很好玩。有时候云状物和“思维泡泡”结合起来，会产生一种梦幻的感觉。云状物可以是三维的泡泡或者只是平面的。许多的云状物Logo用“思维泡泡”来代表一种新思想。
许多的“云朵”来自互联网上的新生意，互联网确实是个梦想之地。有一些，也包含太阳的图形，用来形成“新的曙光”的感觉。

3. Reflections

Mirror, mirror, on the wall, what's the hottest trend of all? It might just be reflections. With Apple leading the way, looking like all their graphics were set on a shiny table, others are sure to follow. Dubbed by some as ?the new drop shadow,? reflections are taking over, especially on the web. The reflections might be skewed, such as in the Logo for blinklist, indicating the location of some light source, invisible to the onlooker, but effective in creating even more of a sense of a whole different world the Logo is in.

3. 反射效果（镜像效果）

魔镜魔镜告诉我，什么是最热的潮流啊？它可能就是“反射效果”。苹果最先开始倡导的，把什么东西都弄得好像放在光滑闪亮的桌面上，其他人就开始跟风。有人给它起了个绰号叫什么来着？“新的下拉阴影”（意思和以前的“下拉阴影”效果一样满天飞）。 “反射效果”全面霸占，尤其是在网上。反射效果可以是不对称的，就像 blinklist 的Logo一样，弄出一些光的效果却让你找不到光源，但对于创造拥有更多“完全不同的世界”感觉的Logo是有效而时尚的。

4. Rectangle

In a graphic world where you can do nearly anything, some companies are keeping it simple with shaded rectangles. Their Logo, in a contrasting white, pops out from the background. Shadow boxes have historically been a sign of amateurish design, but this new generation of effective Logos has shown that good design will always be in style. With the popularity of rounded corners, these Logos stand out with (oh no!) sharp edges and right angles. In some occasions, such as with the blurb Logo, the rectangle can represent an image. Blurb used their blue shadow behind their name to symbolize a book, as they are in the book publishing business.

4. 长方形

在图形世界里，你几乎可以做任何事情，但有些公司只使用简单的带边框的长方形。他们的Logo，从高反差的白色背景上“跳”出来。相框一样的长方形容易给人“业余设计水平”的感觉，但是新生的有活力的这些Logo，表明了好的设计永远都是有品味的。与人气极旺的圆角风格同时，这些Logo因有着锐利的边缘和适当的倾斜角度而特别显眼（不是吧！）。在某些场合，就像 Blurb的Logo，长方形可以用于扮演一个形象。Blurb 用蓝色的图形放在名字后面来代表一本书，因为他们做的是图书出版业务。

5. 3d Puffies

With these new puffed-up Logos, you don't know whether to click on them or bounce on them. Now that the industry has overcome the production issues of gradients, designers seem to prefer air-popped graphics to the flat drawings of yore. Even desktop icons these days seem to have a rounded feel, like you might pop one with one good hard double-click. It's a 2D world out there in Internet land, and these 3D images really make Web pages and Logos jump out of the page, to where you feel you could run your hands over the computer screen and feel their bumps and curves.

5. 立体发泡物

这些新出现的圆鼓鼓发泡Logo，让你搞不懂到底是在上面点击还是在上面弹跳。自从工业生产克服了“渐变色”的难题，设计师们就似乎热衷于将“立体弹出”的图像加到以往的平面图样中。甚至桌面图标在最近也看起来有圆乎乎的感觉，就像你用力一点击它就会弹得老高。二维的世界已经从互联网走开了，三维的图像的确让网页和Logo“跳出”页面，进入一个你可以用手指满屏幕去感觉那些凹凸不平和曲线的新世界。

6. Hot Dogs

These cute little Tic Tacs of color are popping up all over the design world. Like many abstract symbols, the hot dogs can be used to mean many different things. Sometimes they denote movement or sound, such as in the Logo for Snap. These lines, reminiscent of those drawn out of shocked cartoon people by children everywhere, can denote an idea, a feeling or a literal meaning. But no matter how they're used in design, they are a powerful symbol of an upbeat emotion.

6. 热狗肠

这些色彩和弹出的可爱小把戏遍布了整个设计界。像许多抽象符号一样，热狗肠可以用来表示许多不同的东西。又是他们表示声音或运动的警示，就像Snap的Logo里那样。那些辐射的线条，让人想起随处可见的小孩子画的大吃一惊的卡通人物。它能表示一种想法，一种感觉或者只是一种字面上的意义。但不管它们用在设计中是为什么，它们都是一种有强烈表现力的符号来象征乐观的态度。

7. Transmission beam

With satellite tv and radio and wireless everything all the rage in the new millennium, a transmission beams are a quick way to show that they are on the cutting edge of technology. Many companies who use this Logo trend deal in internet information. Part of what many of these companies are doing on the internet is taking user (or customer) information and sharing it with the world. The transmission beam, starting with a single dot (to represent the user), shows their ideas spreading out. It's the perfect symbol for publishing companies or blog sites.

7. 发射电波

卫星电视，电台和无线的东东在新纪元里遍地开花，用发射电波是最快捷方式来表明他们是站在科技的最前沿。用这种Logo的许多公司都在做互联网信息生意。他们中间有许多公司做的是在互联网上获取用户（客户）资料然后分享给全世界。无线电波，始发于一个“点”（代表用户），体现他们的理念在传播。对于出版公司和博

8. People

AOL's little man has some company, with others creating buddies to include in their Logos. For companies that bring people together, these genderless little people are shown in pairs or groups. They provide a visual indicator of coming together. Others show just one of these symbols, usually as an avatar for their customer. Anyone looking for other people can be sure they've found them when they see a Logo with a buddy.

8. 人形

美国在线的“小人”已有了几个军团，和其他正在创建的好友一起都归属在它的Logo旗下。军团将人聚在一起，把这些搞不清性别的人成对或成组排列。他们为“聚在一起”提供了这样一个视觉指示。有些公司的Logo只展示符号中的一个，这通常作为他们客户的偶像。任何想找人的人，当他们看到有这个 Logo的哥们，就能确信自己可以找到队伍。

9. Transparency

Transparency is still hot. Again, many may gasp as the mere though of using a shadow, but this updated version is nothing like the shadow boxes that have plagued generic design. These Logos invoke images of blending together. Some, like the two transmission bubbles that seem to be popping out the little people in the BlueDot Logo, can symbolize communication, or a sort of overlapping and blending of ideas. Others are a Venn diagram, showing where the company fits, such as Zopa.

9. 透明效果

透明效果仍旧热门。强调一下，很多人的需求只不过是加上个相框样的东东，但是这个“升级版”一点都不象相框那样是令人厌倦的普通设计。这些Logo 让图像混合在一起。有些，象是两个传送的泡泡，它们看起来象是要把“小人”弹出来（见BlueDot的Logo），它可以象征沟通，或者观念的混合和重叠的排序。另外的看起来象“交集图”(Venn diagram)，展现出什么是公司的业务范围，就像 Zopa。

10. Outlines

(I think this is another way to add sophistication, 3d effect to a Logo)
Many are finding that nothing brings a Logo to the next level like a professionally done outline. These surrounding lines or shades can simply run around the text or seem to encapsulate it in a bubble, as seen in the picturecloud.com Logo. These outlines can take text and make it seem as though it's one unit. Nicely done, these effects add sophistication and a third dimension to Logos.

10. 轮廓线

（我想这是另外一个方法来锦上添花，弄点立体效果到Logo上。）
很多人发现，没有什么比用轮廓线更能使Logo看起来显得专业。这些环绕着的线或者框可以直接用在文字的周围或是看起来象塑封在一个泡泡里，就像在picturecloud.com 的Logo里一样。这些轮廓线能让文字看起来就像是一个整体。干得漂亮，这些效果的确给Logo锦上添花并有了立体感。

11. Punctuation

From smiley faces to complex illustrations, every day punctuation has gained a new life in the tech typing world of the internet. While some used to only be used to denote the f-word, they're now used in the young on-line world on instant messaging, e-mailing and teen-speak in general. Now, these symbols have jumped out of instant messaging and onto billboards as of late, with their meanings left to the imagination of customers.

11. 标点符号

从笑脸图案到复杂插图，在互联网的文字输入世界里，标点符号每天都会获得新生。当某些人习惯于只用 F-word（粗俗语言，Fxxk字头的词汇）来表达时，它们现在就被年轻人用在即时聊天，E-Mail和小青年们的日常对话里。现在这些符号从即时聊天软件和聊天室里蹦出来，带着它们的涵义留给用户无限的想像空间。

天边一片伴月星 2007-03-08 11:38 发表评论

转compass （http://www.agilejava.org/space/?108/action_viewspace_itemid_172.html）

天边一片伴月星 — Mon, 29 Jan 2007 10:21:00 GMT

     Compass是一流的开放源码JAVA搜索引擎框架，对于你的应用修饰，搜索引擎语义更具有能力。依靠顶级的Lucene搜索引擎，Compass 结合了，像 Hibernate和 Sprin的流行的框架，为你的应用提供了从数据模型和数据源同步改变的搜索力.并且添加了2方面的特征,事物管理和快速更新优化. Compass的目标是：把java应用简单集成到搜索引擎中.编码更少，查找数据更便捷。
    下面以一个应用场景分步骤讲解如何利用compass实现搜索引擎：
1. 这里我们有一个Article表，希望利用compass实现对它的搜索。
  Article的结构如下：
  CREATE TABLE `article` (
    `ArticleID` bigint(20) NOT NULL,
    `PersonInfoID` bigint(20) default NULL,
    `ArticleTitle` varchar(200) default NULL,
    `PublishDate` datetime default NULL,
    `Summary` text,
    `Content` longtext,
    `KeyList` text,
    PRIMARY KEY (`ArticleID`),
    KEY `PersonInfoArticle_FK` (`PersonInfoID`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  我们希望利用compass对它的ArticleTitle、Summary、Content和KeyList进行全文检索。下面开始行动吧。

2. 首先到http://www.opensymphony.com/compass/download.action 上下载一个compass的发布版，我们下载的是Version 1.0.0的With Dependencies 。这样就可能省去寻找相关信赖库的麻烦了。

3. 将compass1.0解压到一个合适的目录，我们的工作目录是d:\develop\compass1.0

4. 我们是在eclipse环境下实现当前要求的，所以建议你也安装一个eclipse 3.2。

5. 首先我们在eclipse中建立了一个java工程，名为mycompass。

6. 然后我们在工程目录中建立了一个lib目录，用来存放本次工程所需要的所有compass和其它相关的库文件，并将他们设置为当前工程构建路径中需要的库文件。所有这些文件可以在compass的安装目录的lib目录找到。

  下面是我们的库文件列表：

7. 建立了Article表的pojo类。
  package com.darkhe.sample.mycompass;

  // Generated 2006-8-2 10:57:06 by Hibernate Tools 3.2.0.beta6a

  import java.util.Date;

  /**
   * Article generated by hbm2java
   */
  public class Article implements java.io.Serializable {

   // Fields

   private long articleId;

   private Long personInfoId;

   private String articleTitle;

   private Date publishDate;

   private String summary;

   private String content;

   private String keyList;

   // Constructors

   /** default constructor */
   public Article() {
   }

   /** minimal constructor */
   public Article(long articleId) {
    this.articleId = articleId;
   }

   /** full constructor */
   public Article(long articleId, Long personInfoId, String articleTitle,
     Date publishDate, String summary, String content, String keyList) {
    this.articleId = articleId;
    this.personInfoId = personInfoId;
    this.articleTitle = articleTitle;
    this.publishDate = publishDate;
    this.summary = summary;
    this.content = content;
    this.keyList = keyList;
   }

   // Property accessors
   public long getArticleId() {
    return this.articleId;
   }

   public void setArticleId(long articleId) {
    this.articleId = articleId;
   }

   public Long getPersonInfoId() {
    return this.personInfoId;
   }

   public void setPersonInfoId(Long personInfoId) {
    this.personInfoId = personInfoId;
   }

   public String getArticleTitle() {
    return this.articleTitle;
   }

   public void setArticleTitle(String articleTitle) {
    this.articleTitle = articleTitle;
   }

   public Date getPublishDate() {
    return this.publishDate;
   }

   public void setPublishDate(Date publishDate) {
    this.publishDate = publishDate;
   }

   public String getSummary() {
    return this.summary;
   }

   public void setSummary(String summary) {
    this.summary = summary;
   }

   public String getContent() {
    return this.content;
   }

   public void setContent(String content) {
    this.content = content;
   }

   public String getKeyList() {
    return this.keyList;
   }

   public void setKeyList(String keyList) {
    this.keyList = keyList;
   }

  }

8. 建立hibernate的pojo到数据表映射文件

  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

9. 开始配置compass，首先是compass的系统配置文件 mycompass.cfg.xml

xmlns="http://www.opensymphony.com/compass/schema/core-config"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.opensymphony.com/compass/schema/core-config
http://www.opensymphony.com/compass/schema/compass-core-config.xsd">

在上面的配置中，我们使用的我们选用的一个中文分词算法库，你可以用compass自带的。具体compass提供了哪些分词算法，请查阅compass的手册。

10. 然后是mycompass.cmd.xml

"-//Compass/Compass Core Meta Data DTD 1.0//EN"
"http://www.opensymphony.com/compass/dtd/compass-core-meta-data.dtd">

        Mycompass Meta Data
        http://com/darkhe/sample/mycompass




            Article alias
            http://com/darkhe/sample/mycompass/alias/Article
            Article




            ArticleTitle
            http://com/darkhe/sample/mycompass/alias/ArticleTitle
            ArticleTitle



            PublishDate
            http://com/darkhe/sample/mycompass/alias/PublishDate
            date



            Summary
            http://com/darkhe/sample/mycompass/alias/Summary
            Summary



            Content
            http://com/darkhe/sample/mycompass/alias/Content
            Content

            KeyList
            http://com/darkhe/sample/mycompass/alias/KeyList
            KeyList

11. 再是mycompass.cpm.xml

"-//Compass/Compass Core Mapping DTD 1.0//EN"
"http://www.opensymphony.com/compass/dtd/compass-core-mapping.dtd">

   ${mycompass.ArticleTitle}

   ${mycompass.PublishDate}

   ${mycompass.Summary}

   ${mycompass.Content}

   ${mycompass.KeyList}

12. log4j.properties
log4j.rootLogger=WARN, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p %c - %m%n
log4j.logger.org.compass=INFO

13. jdbc.properties
# Properties file with JDBC-related settings.
# Applied by PropertyPlaceholderConfigurer from "applicationContext-*.xml".
# Targeted at system administrators, to avoid touching the context XML files.
jdbc.driverClassName=com.mysql.jdbc.Driver
#jdbc.driverClassName=org.hsqldb.jdbcDriver
#jdbc.url=jdbc:hsqldb:hsql://localhost:9001
jdbc.url=jdbc:mysql://localhost:3306/testdb
jdbc.username=test
jdbc.password=test
# Property that determines the Hibernate dialect
# (only applied with "applicationContext-hibernate.xml")
#hibernate.dialect=org.hibernate.dialect.HSQLDialect
hibernate.dialect=org.hibernate.dialect.MySQLDialect

14. 最后是applicationContext-hibernate.xml，这里集中配置了compass如何与spring与hibernate结合的。

http://www.springframework.org/dtd/spring-beans.dtd">

   class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

   classpath:jdbc.properties


   class="org.springframework.jdbc.datasource.DriverManagerDataSource">

   ${jdbc.driverClassName}


   ${jdbc.url}


   ${jdbc.username}


   ${jdbc.password}


   class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">






     com/darkhe/sample/mycompass/Article.hbm.xml






     ${hibernate.dialect}

    false
    true





           class="org.springframework.orm.hibernate3.support.IdTransferringMergeEventListener" />

    classpath:mycompass.cmd.xml
    classpath:mycompass.cpm.xml



   classpath:mycompass.cfg.xml

   class="org.compass.spring.device.hibernate.SpringHibernate3GpsDevice">

   hibernateDevice





   init-method="start" destroy-method="stop">





         class="org.compass.spring.device.SpringSyncTransactionGpsDeviceWrapper">

15. 注意上面的所以配置文件，根据我们上面的配置，都应当放到classpath的根路径。
16. 建立工具类，用来进行spring引擎的初始化工作。
/**
*

@(#) IOC.java 2006-2-1 0:08:23

*/
package com.darkhe.sample.mycompass;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
*
*
* @version 1.0 2006-2-1
* @author darkhe
*/
public class IOC {
private static ApplicationContext context = null;

private static boolean isInit = false;

private IOC() {
super();
}

private static void init() {

if (isInit == false) {
String[] xmlfilenames = { "applicationContext-hibernate.xml" };

context = new ClassPathXmlApplicationContext(xmlfilenames);

isInit = true;
}
}

/**
*
* @return
*/
public static ApplicationContext getContext() {
  if (context == null || isInit == false) {
   init();
  }
  return context;
}

/**
*
* @param name
* @return
*/
public static Object getBean(String name) {
return getContext().getBean(name);
}

}

17. 建立索引程序，用来数据库中的建立索引
/*
* Copyright (c) 2005-2006
* ChongQing Man-Month Technology Development Co. ,Ltd
*
* ---------------------------------------------------------------------------------
* @(#) Inder.java, 2006-8-1 下午09:01:14
* ---------------------------------------------------------------------------------
*/
package com.darkhe.sample.mycompass;

import java.io.FileNotFoundException;

import org.compass.gps.CompassGps;
import org.springframework.context.ApplicationContext;

/**
* @author darkhe
*
*/
public class Indexer {

/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {

// 加裁自定义词典
DictionaryUtils.loadCustomDictionary();

ApplicationContext context = IOC.getContext();

  // 得到spring环境中已经配置和初始化好的compassGps对象
  CompassGps compassGps = (CompassGps) context.getBean("compassGps");
  // 调用index方法建立索引
  compassGps.index();

}

18. 建立搜索程序，检证compass的应用。
/*
* Copyright (c) 2005-2006
* ChongQing Man-Month Technology Development Co. ,Ltd
*
* ---------------------------------------------------------------------------------
* @(#) Searcher.java, 2006-8-1 下午09:36:29
* ---------------------------------------------------------------------------------
*/

package com.darkhe.sample.mycompass;

import java.io.FileNotFoundException;

import org.compass.core.Compass;
import org.compass.core.CompassCallbackWithoutResult;
import org.compass.core.CompassException;
import org.compass.core.CompassHits;
import org.compass.core.CompassSession;
import org.compass.core.CompassTemplate;
import org.compass.core.Resource;
import org.springframework.context.ApplicationContext;

/**
* @author darkhe
*
*/
public class Searcher {

/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {

// 加裁自定义词典
DictionaryUtils.loadCustomDictionary();

ApplicationContext context = IOC.getContext();

Compass compass = (Compass) context.getBean("compass");

CompassTemplate template = new CompassTemplate(compass);

  template.execute(new CompassCallbackWithoutResult() {
   protected void doInCompassWithoutResult(CompassSession session)
     throws CompassException {
    CompassHits hits = session.find("大头人");

    System.out.println("Found [" + hits.getLength()
      + "] hits for [大头人] query");
    System.out
      .println("======================================================");
    for (int i = 0; i < hits.getLength(); i++) {
     print(hits, i);
    }

    hits.close();
   }
  });

}

public static void print(CompassHits hits, int hitNumber) {
  Object value = hits.data(hitNumber);
  Resource resource = hits.resource(hitNumber);
  System.out.println("ALIAS [" + resource.getAlias() + "] SCORE ["
    + hits.score(hitNumber) + "]");
  System.out.println(":::: " + value);
  System.out.println("");
}
}

19. 工具类DictionaryUtils是用来管理我们自己采用的中文分词算法的加载自定义词典的。
/**
* Copyright (c) 2005-2006 重庆人月科技发展有限公司
*
* ------------------------------------------------------------------------------
* @(#) DictionaryUtils.java, 2006-8-2 下午04:55:22
* ------------------------------------------------------------------------------
*/
package com.darkhe.sample.mycompass;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

import jeasy.analysis.MMAnalyzer;

/**
*
* @author darkhe
* @version 1.0.0
*/
public class DictionaryUtils {
// 静态变量
private static boolean isInit = false;

// 静态初始化

// 静态方法
public static void loadCustomDictionary() throws FileNotFoundException {

if (isInit == false) {

   // 添加我们自己的词典
   FileReader fr = new FileReader(new File("dict.txt"));
   MMAnalyzer.addDictionary(fr);

   //System.out.println("添加我们自己的词典");

isInit = true;
}
}
}
20. 执行Indexer，再执行Seracher后控制台信息如下：

Found [1] hits for [大头人] query
================================================
ALIAS [Article] SCORE [0.3988277]
:::: com.darkhe.sample.mycompass.Article@bla4e2

具体结果和你的数据表中的内容有别。

21. 这样，我们便实现了如何利用compass构建我们自己的搜索引擎的一个简单实现。

天边一片伴月星 2007-01-29 18:21 发表评论

COMPASS应用(转)

天边一片伴月星 — Mon, 29 Jan 2007 10:12:00 GMT

一个简单的COMPASS应用

首先你要下载Compass framework: Download Compass.
你需要在你的class path 中添加4个jarcompass-x/modules/core/compass-core-x.jar, compass/modules/core/lib/commons-logging-x.jar, compass-x/modules/core/lib/log4j-x.jar, compass-x/modules/core/lib/lucene-core-x-rc1-dev.jar.
在你的项目中创建下面的目录(可以根据自己的定义来改动)：

log4j.properties 
- org 
   - compassframework 
     - sample 
       - example 
           alias.cmd.xml 
           compass.cfg.xml 
           CompassExample.java 
           Phrase.cpm.xml 
           Phrase.java

下面说一下几个重要的配置文件

compass.cfg.xmlcode

指定的target/index 是一个存储目录放索引文件的

（这个类必须有个无参数的构造和id属性）

xml 代码

"http://static.compassframework.org/dtd/compass-core-configuration-1.0.dtd" >
<
compass-core-configuration >
< compass >
< setting name = "compass.engine.connection" > target/index setting >
< meta-data resource = "org/compassframework/sample/example/alias.cmd.xml" />
compass >
compass-core-configuration >

alias.cmd.xml:

xml 代码

xml version = "1.0" ?>
"-//Compass/Compass Core Meta Data DTD 1.0//EN"
"http://static.compassframework.org/dtd/compass-core-meta-data-1.0.dtd" >
< compass-core-meta-data >
< meta-data-group id = "example" displayName = "Example Meta Data" >
< description > Example Meta Data description >
< uri > http://compass/example uri >
< alias id = "phrase" displayName = "Phrase" >
< description > Phrase alias description >
< uri > http://compass/example/phrase uri >
< name > phrase name >
alias >
< meta-data id = "author" displayName = "Author" >
< description > Author alias description >
< uri > http://compass/example/author uri >
< name > author name >
meta-data >
< meta-data id = "text" displayName = "Text" >
< description > Text alias description >
< uri > http://compass/example/text uri >
< name > text name >
meta-data >
meta-data-group >
compass-core-meta-data >

Phrase.java


														java 代码
														
																
																		
																		
																		
																				
																						
																								package
																								 org.compassframework.sample.example;   
																						
																				
																				
																						  
																				
																				
																						
																						
																						public
																						 
																						class
																						 Phrase {   
																				
																				
																						  
																				
																				
																						 
																						private
																						 String author;   
																				
																				
																						  
																				
																				
																						 
																						private
																						 String text;   
																				
																				
																						  
																				
																				
																						 
																						private
																						 Long id;   
																				
																				
																						  
																				
																				
																						 
																						public
																						 Phrase() {   
																				
																				
																						  
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 String getAuthor() {   
																				
																				
																						     
																						return
																						 author;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 
																						void
																						 setAuthor(String author) {   
																				
																				
																						     
																						this
																						.author = author;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 String getText() {   
																				
																				
																						     
																						return
																						 text;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 
																						void
																						 setText(String text) {   
																				
																				
																						     
																						this
																						.text = text;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 Long getId() {   
																				
																				
																						     
																						return
																						 id;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 
																						void
																						 setId(Long id) {   
																				
																				
																						     
																						this
																						.id = id;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						 
																						public
																						 String toString() {   
																				
																				
																						  
																				
																				
																						     
																						return
																						 text;   
																				
																				
																						 }   
																				
																				
																						  
																				
																				
																						}    
																				
																		
																
														
														Phrase.cpm.xml


												
														xml 代码
														
																
																
																
																		
																				
																						xml version="1.0"?>    
																				
																		
																		
																				
																		
																		
																				"-//Compass/Compass Core Mapping DTD 1.0//EN"    
																		
																		
																				"http://static.compassframework.org/dtd/compass-core-mapping-1.0.dtd"
																				>
																				    
																		
																		
																				
																				
																				<
																				compass-core-mapping
																				 
																				package
																				=
																				"org.compassframework.sample.example"
																				>
																				    
																		
																		
																				
																				
																				<
																				class
																				 
																				name
																				=
																				"Phrase"
																				 
																				alias
																				=
																				"${example.phrase}"
																				>
																				  
																		
																		
																				  
																		
																		
																				
																				
																				<
																				id
																				 
																				name
																				=
																				"id"
																				 
																				/>
																				  
																		
																		
																				  
																		
																		
																				
																				
																				<
																				property
																				 
																				name
																				=
																				"author"
																				>
																				  
																		
																		
																				  
																		
																		
																				
																				
																				<
																				meta-data
																				>
																				${example.author}
																				
																						meta-data
																						>
																						  
																				
																		
																		
																				  
																		
																		
																				
																				
																				
																						property
																						>
																						  
																				
																		
																		
																				  
																		
																		
																				
																				
																				<
																				property
																				 
																				name
																				=
																				"text"
																				>
																				  
																		
																		
																				  
																		
																		
																				
																				
																				<
																				meta-data
																				>
																				${example.text}
																				
																						meta-data
																						>
																						  
																				
																		
																		
																				  
																		
																		
																				
																				
																				
																						property
																						>
																						  
																				
																		
																		
																				  
																		
																		
																				
																				
																				
																						class
																						>
																						  
																				
																		
																		
																				  
																		
																		
																				
																				
																				
																						compass-core-mapping
																						>
																						  
																				
																		
																
														
CompassExample.java

java 代码

package org.compassframework.sample.example;
import org.apache.log4j.Logger;
import org.compassframework.core.Compass;
import org.compassframework.core.Compass;
import org.compassframework.core.CompassSession;
import org.compassframework.core.CompassTransaction;
import org.compassframework.core.config.CompassConfiguration;
public class CompassExample {
private static final Logger logger = Logger.getLogger(CompassExample. class );
private compasscompass;
public static void main(String[] args){
new CompassExample().process();
}
private void process(){
CompassConfiguration config = new CompassConfiguration();
config.configure( "org/compassframework/sample/example/compass.cfg.xml" );
config.addClass(Phrase. class );
compass = config.buildCompass();
compass.getSearchEngineIndexManager().deleteIndex();
compass.getSearchEngineIndexManager().createIndex();
createIndex();
search( "mule AND crazy" );
search( "Marisol OR Ramon" );
}
private void createIndex(){
CompassSession session = compass.openSession();
CompassTransaction tx = session.beginTransaction();
Phrase phrase = new Phrase();
phrase.setAuthor( "Joe" );
phrase.setText( "I don't think it's nice you laughing. " +
"You see my mule don't like people laughing. " +
"He gets the crazy idea you're laughing at him. " +
"Now if you apologize like I know you're going to, " +
"I might convince him that you really didn't mean it..." );
phrase.setId( new Long( 1 ));
session.save(phrase);
tx.commit();
session.close();
}
private void search(String query){
CompassSession session = compass.openSession();
CompassTransaction tx = session.beginTransaction();
Compass hits = session.find(query);
if (logger.isDebugEnabled()) {
logger.debug( "search() - Found " + hits.getLength()+ " hits for \"" +query+ "\"" );
}
for ( int i = 0 ; i < hits.getLength(); i++) {
print(hits, i);
}
hits.close();
tx.commit();
session.close();
compass.close();
}
private void print(Compass hits, int hitNumber) {
Phrase value = (Phrase)hits.data(hitNumber);
if (logger.isDebugEnabled()) {
logger.debug( "print() - Phrase by " + value.getAuthor() + ": "
+ value.getText());
}
}
}

为了保证能打印出我们的测试，需要加入log4j.properties ：
log4j.rootLogger=ERROR, stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d %p %c - %m%n log4j.logger.org.compassframework.sample.example=DEBUG

下面是打印出来的测试结果：
search() - Found 1 hits for "mule AND crazy" print() - Phrase by Joe: I don't think it's nice you laughing... search() - Found 0 hits for "Marisol OR Ramon"

天边一片伴月星 2007-01-29 18:12 发表评论

Compass

天边一片伴月星 — Mon, 29 Jan 2007 10:11:00 GMT

下面阐述Compass的一些名词：

1：Resource，Compass对Lucene的Document的抽象，与Alias联系在一起。

2：Property，Compass对Lucene的Field的抽象。通过Compass Converter framework将不是String类型的对象转换为可以索引的Property。

3：RSEM：Resource/Search Engine Mapping，资源搜索引擎影射。

4：Lucene采用IndexReader、Searcher、IndexWriter三个类完成索引搜索的功能。而Compass只有一个简单的接口，能够通过该接口实现所有的操作。

5：事务索引和集成：lucene是非事务性的。无法和事务型的系统进行结合。Compass提供两种提交事务：read_committed 和 serializable。

6：快速更新：lucene中，执行更新必须先删除旧的Document，然后再新建一个Document。由于Compass支持事务索引，因此每个要保存的Resource都必须有一个唯一标识。这样更新的效率会更高。

7： All 支持：在lucene中，没有办法对一个Document的所有的字段进行搜索，要对所有字段进行搜索，必须创建一个包含所有field的一个 "all"field。compass默认地建立一个"all"属性，并且该"all"属性充当默认的搜索Field，当然，"all"property 可以设置成enabled或disabled、重命名或者不充当默认的搜索Property，也可以排除all中的某些属性。

8：索引分块，

来源:http://bbs.xml.org.cn/blog/more.asp?name=lhwork&id=18505

作者：地狱男爵

compass官方网站: http://www.compassframework.org/

Compass是一流的JAVA搜索框架，可以快速修饰你的应用，使其具备Searchable的能力。

在没有Compass，单纯用Lucene的环境里，一般做法是定期遍历数据库，编码将里面的内容转为索引。

而Compass通过与 Hibernate和 Spring的结合，简单的为Domain Object提供了到Lucene引擎的映射，而且索引库能够随Domain Object同步更新(Data Mirror)。

1 Quick Start

2 对象/搜索引擎映射(OSEM)

天边一片伴月星 2007-01-29 18:11 发表评论

cocoon xsp

天边一片伴月星 — Fri, 26 Jan 2007 04:02:00 GMT

XSP (eXtensible Server Page )作为Cocoon的一个重要的组成部分可以为Cocoon的pipeline生成XML文件。XSP文件本身是XML文件，遵循XML的规范，但是支持在XML文件中包含程序代码。XSP借助Bean Scripting Framework支持多种语言，包括Java，Javascript，Python 等。

XSP文件的根元素为，通常使用xsp名字空间（）。
一个简单的例子如：

1: 2: 3: 4: 5: language=”java” 6: xmlns:xsp=”http://apache.org/xsp”> 7: 8: 9: new java.util.Date().toString() 10: 11:

2004年出版的Professional XML Development with Apache Tools: Xerces, Xalan, FOP, Cocoon, Axis, Xindice一书称2行是必须的，但是我在Cocoon 2.1.9下测试发现，其中的第2行声明可以去掉。

下面看一个在XSP里定义一个函数的例子：

1: 2: 3: 4: 5: language=”java” 6: xmlns:xsp=”http://apache.org/xsp”> 7: 8: 9: java.util.Date 10: 11: 12: 13: String getDate() { 14: Date d = new Date(); 15: return d.toString(); 16: } 17: 18: 19: 20: getDate() 21: 22:

可以看到，定义函数的代码被放在了元素里，另外使用和其子元素元素可以导入Java的类。

完整的XSP元素列表如下：

<?cocoon-process?> This processing instruction (PI) tells Cocoon how to process this file. You may have multiple cocoon-process PIs because Cocoon can process an XSP page in two different ways. It can process the document as an XSP file, causing the language code to be executed. To indicate this style of processing, specify “xsp” as the value of the type pseudo-attribute. Cocoon can also use an XSL stylesheet to transform the document. This can occur either before or after the XSP processing. The processing order is determined by the order in which the PIs appear in the document. To use a stylesheet with an XSP document, specify “xslt” as the value of the type pseudo-attribute. If you use a stylesheet with the document, you need to supply an XML stylesheet processing instruction that tells where to find the stylesheet. (See the next item.)
<?xml-stylesheet?> This PI is defined by the W3C’s Associating Style Sheets with XML Documents recommendation. Associating a stylesheet is easy; you supply two pseudo-attributes. The href pseudo-attribute contains the URI for the stylesheet, and the type pseudo-attribute contains the MIME type of the stylesheet, which should be “text/xsl” for XSLT stylesheets.
<xsp:page> The root element of an XSP page is . It takes a language attribute that allows you to specify the programming language being used in the XSP. You’ll probably also define some namespace prefixes on this element. The minimum would be for you to define the xsp prefix. The must contain at least one user-defined element that’s used as the root element of the XSP result.
<xsp:structure> This element is a container for elements.
<xsp:include> XSP uses the element to import type definitions that are needed by the rest of the XSP. In Java, these are specified either as fully qualified classnames or in wildcarded package style, like java.util.*.
<xsp:logic> The implementation of the logic of an XSP should be the content of the element. For Java-based XSPs, this includes member fields and methods.
<xsp:expr> An element invokes logic in the to return a string valued expression. In Java, this is through method calls, field accesses, or string literals. Java string literals that appear as the content of an tag must be inside double quotes (”").
<xsp:element> This element allows you to dynamically create an element in the output XML. The element takes a name attribute whose value is the name of the element to be created. You can nest these elements to create element subtrees dynamically. You can also insert literal XML elements and character data as part of the content of this element.
<xsp:attribute> The element should appear as the child of either an element or a literal XML element. It allows you to dynamically create an attribute by supplying a name attribute for the name of the new attribute. The value of the new attribute is the content of the element.
<xsp:comment> To create a comment in the XSP output, use the element and make the content of the element the text of your comment.
<xsp:pi> The element allows you to create processing instructions. You supply a target attribute that defines the PI target name. If you wish to create pseudo-attributes, you do so via elements in the content of the element. So, to create a PI that looks like , your element would look like this:
```
    "href=\"sheet.xsl\" type=\"text/xsl\""  
```
<xsp:content> You can use the element inside an element to insert the Java code for an XSP fragment at that point on the program. This is particularly useful for inserting an XSP fragment that is to be output as the body of a loop.

xsp:page — XSP 文档的根元素，它必须只包含一个用户元素
xsp:structure、xsp:include — 允许将附加的 Java 类导入到 XSP 的已编译版本中
xsp:logic — 允许在 XSP 的已编译版本中包含附加的编程代码块；这可以包含成员变量、方法或应用程序逻辑
xsp:expr — 允许对 Java 表达式求值，并将它们的值添加到文档
xsp:element — 允许 XSP 动态创建元素；这些元素可以用任意名称创建，并且可以与任何名称空间和前缀关联
xsp:attribute — 允许将属性动态地添加到元素；这些属性可以用任意名称和值创建，并且可以与任何名称空间关联
xsp:comment — 允许将注释添加到已生成的文档
xsp:pi — 允许动态创建处理指令，并将之添加到已生成的文档
xsp:parameter — 允许为元素或属性生成名称

通过使用 xsp:element，还可以动态地创建元素，如：

"myElementName"
Element content

这个示例显示了用动态生成名称创建元素涉及使用 xsp:element 和 xsp:param 元素。xsp:param定义了一个参数，在本例中是元素的名称，其值是一个用于计算元素名称的表达式。

上面的代码将生成 XML 输出

Element content

用这种方式创建的元素还可以与一个特定的名称空间和前缀关联，如下例所示。请注意：这两个名称空间和前缀参数都是必需的；否则将产生错误。

"myElementName" Element content

这个示例生成了以下 XML 输出：

Element content

如同元素一样，可以在 XSP 页面中动态创建属性。xsp:attribute 元素的工作原理类似于 xsp:element，它允许动态创建属性的名称及其值：

"myElementName"
myAttributeValue
Element content

这个属性的名称定义在 name 属性内，尽管是用与 xsp:element 类似的方法定义的，但它还能通过使用 xsp:param 子元素来定义。属性值被指定成元素内容。这可以是一个简单文本值或更有效地由 xsp:expr 元素生成。

而 xsp:attribute 标记不必与 xsp:element 结合使用。它可以被放置在任何用户元素内，而且可以用相同的方法添加属性。例如，可以通过使用调用定义在 XSP 页面别处的方法的表达式来动态创建 image 元素的 URL。

calculateImageURL()

如果生成的属性与特定的名称空间关联，那么这可以通过使用附加的 prefix 和 uri 属性或 xsp:param 元素来表示，它类似于用于 xsp:element 的方法。同样，如果只定义了其中的一个，则是一个错误。

创建注释和处理指令

xsp:comment 和 xsp:pi 元素用于创建注释和处理指令。

创建注释十分简单。任何作为 xsp:comment 元素的子元素而提供的文本都变成了 XML 注释：

This is a comment

然后这个注释变成：

创建处理指令类似于创建动态元素或属性。xsp:pi 元素应该有一个标识处理指令目标的嵌套参数。照例对 xsp:pi 元素的剩余内容求值。这里是一个简单示例：

"param1=value, param2=value, generatorTimestamp=" + System.currentTimeMillis()

输出如下：

还可以通过在 xsp:param 元素内创建处理指令的目标来自动生成它，如同以下示例演示的那样：

"myApplication" "param1=value, param2=value, generatorTimestamp=" + System.currentTimeMillis()

天边一片伴月星 2007-01-26 12:02 发表评论

hibernate Q&A (often)

天边一片伴月星 — Tue, 31 Oct 2006 08:16:00 GMT

　　１、到底在哪用cascade="..."？
　　
　　cascade属性并不是多对多关系一定要用的，有了它只是让我们在插入或删除对像时更方便一些，
    只要在cascade的源头上插入或是删除，所有cascade的关系就会被自己动的插入或是删除。
    便是为了能正确的cascade，unsaved-value是个很重要的属性。
    Hibernate通过这个属性来判断一个对象应该save还是update，如果这个对象的id是unsaved-value的话，
    那说明这个对象不是persistence object要save（insert)；如果id是非unsaved-value的话，
    那说明这个对象是persistence object（数据库中已存在），只要update就行了。saveOrUpdate方法用的也是这个机制。
　　
　　２、到底在哪用inverse="ture"?
　　
　　inverse属性默认是false的，就是说关系的两端都来维护关系。这个意思就是说，
    如有一个Student, Teacher和TeacherStudent表，Student和Teacher是多对多对多关系，
    这个关系由TeacherStudent这个表来表现。那么什么时候插入或删除TeacherStudent表中的记录来维护关系呢？
    在用hibernate时，我们不会显示的对TeacherStudent表做操作。对TeacherStudent的操作是hibernate帮我们做的。
    hibernate就是看hbm文件中指定的是"谁"维护关系，那个在插入或删除"谁"时，就会处发对关系表的操作。
    前提是"谁"这个对象已经知道这个关系了，就是说关系另一头的对象已经set或是add到"谁"这个对象里来了。
    前面说过inverse默认是false，就是关系的两端都维护关系，对其中任一个操作都会处发对表系表的操作。
    当在关系的一头，如Student中的bag或set中用了inverse＝"true"时，那就代表关系是由另一关维护的（Teacher）。
    就是说当这插入Student时，不会操作TeacherStudent表，即使Student已经知道了关系。
    只有当Teacher插入或删除时才会处发对关系表的操作。所以，当关系的两头都用inverse="true"是不对的，
    就会导致任何操作都不处发对关系表的操作。当两端都是inverse="false"或是default值是，
    在代码对关系显示的维护也是不对的，会导致在关系表中插入两次关系。
　　
　　在一对多关系中inverse就更有意义了。在多对多中，在哪端inverse="true"效果差不多（在效率上）。
    但是在一对多中，如果要一方维护关系，就会使在插入或是删除"一"方时去update"多"方的每一个与这个"一"的对象有关系的对象。
    而如果让"多"方面维护关系时就不会有update操作，因为关系就是在多方的对象中的，直指插入或是删除多方对象就行了。
    当然这时也要遍历"多"方的每一个对象显示的操作修关系的变化体现到DB中。不管怎样说，还是让"多"方维护关系更直观一些。
　　
　　３、cascade和inverse有什么区别？
　　
　　可以这样理解，cascade定义的是关系两端对象到对象的级联关系；而inverse定义的是关系和对象的级联关系。
　　
　　４、net.sf.hibernate.ObjectDeletedException: deleted object would be re-saved by
     cascade (remove deleted object from associations): 2, of class: Xxxxx

　　这个问题出现在要删除关系的一头时。如，要删除一个已经和Student有关系的Teacher。当tx.commit();
    时才会抛出这个异常。这时一个在关系另一头的Student对象中的Set或是List中把这个Teacher对象显示的remove掉，
    再session.delete(这个teacher);。这是为了防止在Student端有cascade时把这个Teacher对象再存回DB。
    所以，这个异常的只有在Student的关系定义中有cascade="..."，而且没有像上面说的显示的解除关系时才会出现。
    所以防止出现这个异常的方法就是：1，在Student端不用cascade；2，或是用cascade的话，就显示的删除对像中的关系。
    3，在Teacher端要用cascade
　　
　　５、net.sf.hibernate.HibernateException: identifier of an instance of my.MyObject altered from N to N
　　
　　这个异常其时不是多对多中常遇到的，但是这个异常的提示不make sense，所以提一下，
    是因为id的java对象中的type和hbm文件中定义的不一样，如：java中用long，而hbm中用type="integer"，
    并且generator用的是identity时就会出现

天边一片伴月星 2006-10-31 16:16 发表评论

hibernate summarize

天边一片伴月星 — Tue, 31 Oct 2006 08:14:00 GMT

　1.两种配置文件：
　　A.hibernate.cfg.xml和B.hibernate.properties
　　
　　A中可含映射文件的配置，而B中hard codes加映射文件。
　　
　　A.Configuration config=new Configuration().config();
　　B. Configuration config=new Configuration();
　　config.addClass(TUser.class);
　　
　　2.你不必一定用hibernate.cfg.xml或hibernate.properties这两文件名，你也不一定非得把配置文件放在Classes下，　　File file=new File("c:\\sample\\myhibernate.xml");　　Configuration config=new Configuration().config(file);
　　
　　3. session.Flush() 强制数据库立即同步，当用事务时，不必用flush,事务提交自动调用flush在session关闭时也会调用flush
　　
　　4. Hibernate总是使用对象类型作为字段类型
　　
　　5. XDoclet专门建立了hibernate doclet,就是在java代码上加上一些java docTag，后来再让XDoclet分析该java代码，生成映射文件;
　　
　　6.HQL子句本身大小写无关，但是其中出现的类名和属性名必须注意大小写区分。
　　
　　7.关系：　 Constrained : 约束，表明主控表的主键上是否存在一个外键（foreigh key）对其进行约束。
　　
　　property-ref:关联类中用于与主控类相关联的属性名，默认为关联类的主键属性名
　　
　　单向一对多需在一方配置，双向一对多需在双方进行配置
　　
　　8.lazy=false:被动方的记录由hibernate负责记取，之后存放在主控方指定的Collection类型属性中
　　
　　9. java.util.Set或net.sof.hibernate.collecton.Bag类型的Collection
　　
　　10.重要：inverse:用于标识双向关联中的被动方一端。
　　
　　inverse=false的一方（主控方）负责维护关联关系.默认值：false
　　
　　11.batch-size:采用延迟加载特征时，一次读入的数据数昨。
　　
　　12.一对多通过主控方更新（主控方为一方时）
　　
　　user.getAddresses().add(addr);
　　
　　session.save(user);//通过主控对象级联更新
　　
　　13.在one-to-many 关系中，将many 一方设为主动方（inverse=false）将有助性能的改善。在一方设置关系时，inverse=true,即将主控权交给多方，　　这样多方可主动从一方获得foreign key,然后一次insert即可完工。
　　
　　addr.setUser(user);//设置关联的TUser对象
　　
　　user.getAddresses().add(addr);
　　
　　session.save(user);//级联更新
　　
　　14.只有设为主控方的一方才关心（访问）对方的属性，被动方是不关心对方的属性的。
　　
　　15.one-to-many与many-to-one节点的配置属性不同：
　　
　　一对多关系多了lazy和inverse两个属性多对多节点属性：
　　
　　column:中间映射表中，关联目标表的关联字段
　　
　　class:类名，关联目标类
　　
　　outer-join:是否使用外联接
　　
　　注意:access是设置属性值的读取方式。
　　
　　column是设置关联字段。
　　
　　16.多对多，注意两方都要设置inverse和lazy,cascade只能设为insert-update
　　
　　多对多关系中，由于关联关系是两张表相互引用，因此在保存关系状态时必须对双方同时保存。
　　
　　group1.getRoles().add(role1);　　role1.getGroups().add(group1);
　　
　　session.save(role1);　　session.save(group1);
　　
　　17.关于vo和po　　vo经过hibernate容量处理，就变成了po(该vo的引用将被容器保存，并且在session关闭时flush,因此po如果再传到其它地方改变了，就危险了)　　　 vo和po相互转换：BeanUtils.copyProperties(anotherUser,user);
　　
　　18.对于save操作而言，如果对象已经与Session相关联（即已经被加入Session的实体容器中），则无需进行具体的操作。因为之后的Session.flush过程中，Hibernate 会对此实体容器中的对象进行遍历，查找出发生变化的实体，生成并执行相应的update 语句。
　　
　　19.如果我们采用了延迟加载机制，但希望在一些情况下，实现非延迟加载时的功能，也就是说，我们希望在Session关闭后，依然允许操作user的addresses 属性 Hibernate.initialize方法可以通过强制加载关联对象实现这一功能：这也正是我们为什么在编写POJO时，必须用JDK Collection接口（如Set,Map）, 而非特定的JDK Collection实现类（如HashSet、HashMap）申明Collection属性的原因。
　　
　　20.事务：从sessionFactory获得session,其自动提交属性就已经关闭(AutoCommit=false),此时若执行了jdbc操作，如果不显式调用session.BeginTransaction(),是不会执行事务操作的。
　　
　　jdbc transaction:基于同一个session(就是同一个connection)的事务;
　　
　　jta　transaction:跨session（跨connection）事务.
　　
　　对于jta事务，有三种实现方法：
　　
　　A。UserTransaction tx=new InitialContext().lookup("...");
　　tx.commit();
　　
　　B. 使用hibernate封装的方法：(不推荐)
　　
　　Transaction tx=session.beginTransaction();
　　tx.commit();
　　C. 使用ejb之sessionBean的事务技持方法，你只要在把需要在发布描述符中，把需要jta事务的方法声明为require即可
　　
　　21.悲观锁，乐观锁：　　乐观锁一般通过version来实现，注意version节点必须出现在id后。
　　
　　22.Hibernate中，可以通过Criteria.setFirstResult和Criteria.setFetchSize方法设定分页范围。
　　
　　Query接口中也提供了与其一致的方法，hibernate主要在dialect类中实现在这个功能。
　　
　　23.cache
　　

……
　　
　　net.sf.ehcache.hibernate.Provider　
　　
　　还需对ecache本身进配置
　　
　　　
　　
　　之后在映射文件中指定各个映射实体的cache策略
　　
　　
　　....
　　
　　
　　....
　　
　　
　　***************************************************** Query.list()跟Query.iterate()的不同：对于query.list()总是通过一条sql语句获取所有记录,然后将其读出，填入pojo返回; 但是query.iterate()，则是首先通过一条Select SQL 获取所有符合查询条件的记录的 id，再对这个id 集合进行循环操作，通过单独的Select SQL 取出每个id 所对应的记录，之后填入POJO中返回。
　　
　　也就是说，对于list 操作，需要一条SQL 完成。而对于iterate 操作，需要n+1 条SQL。，list方法将不会从Cache中读取数据。iterator却会。
　　
　　24.ThreadLocal:它会为每个线程维护一个私有的变量空间。实际上，其实现原理是在JVM 中维护一个Map，这个Map的key 就是当前的线程对象，而value则是线程通过ThreadLocal.set方法保存的对象实例。当线程调用ThreadLocal.get方法时， ThreadLocal会根据当前线程对象的引用，取出Map中对应的对象返回。
　　
　　这样，ThreadLocal通过以各个线程对象的引用作为区分，从而将不同线程的变量隔离开来。
　　
　　25.Hibernate官方开发手册标准示例:
　　
　　public class HibernateUtil { private static SessionFactory sessionFactory;
　　static { try { // Create the SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
　　} catch (HibernateException ex) { throw new RuntimeException( "Configuration problem: " + ex.getMessage(), ex );
　　} } public static final ThreadLocal session = new ThreadLocal();
　　public static Session currentSession() throws HibernateException { Session s = (Session) session.get();
　　// Open a new Session, if this Thread has none yet if (s == null) { s = sessionFactory.openSession();
　　session.set(s);
　　} return s;
　　} public static void closeSession() throws HibernateException { Session s = (Session) session.get();
　　session.set(null);
　　if (s != null) s.close();
　　} }
　　
　　26.通过filter实现session的重用：
　　
　　public class PersistenceFilter implements Filter { protected static ThreadLocal hibernateHolder = new ThreadLocal();
　　public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { hibernateHolder.set(getSession());
　　try { …… chain.doFilter(request, response);
　　…… } finally { Session sess = (Session)hibernateHolder.get();
　　if (sess != null) { hibernateHolder.set(null);
　　try { sess.close(); } catch (HibernateException ex) { throw new ServletException(ex);
　　} } } } ……}<>

天边一片伴月星 2006-10-31 16:14 发表评论

hibernate many-to-many case

天边一片伴月星 — Tue, 31 Oct 2006 07:47:00 GMT

SQL(MY SQL):
create table tgroup (
group_id int not null auto_increment,
name varchar(16) not null default ´´,
primary key (group_id)
) type=innodb;

create table trole (
role_id int not null auto_increment,
name varchar(16) not null default ´´,
primary key (role_id)
) type=innodb;

create table tgroup_role (
group_id int not null,
role_id int not null,
primary key(group_id, role_id),
index (group_id),
foreign key (group_id) references tgroup(group_id),
index (role_id),
foreign key (role_id) references trole(role_id)
) type=innodb;

Group 类：
package ivan.hibernate.many2many;
public class Group {
private int id;
private String name;
private Set roles = new HashSet();
...
}

Group.hbm.xml：






                     table="tgroup_role"
             cascade="save-update">

                                        column="role_id"/>

Role 类：
package ivan.hibernate.many2many;
public class Role {
private int id;
private String name;
private Set groups = new HashSet();
...
}

Role.hbm.xml：






                     table="tgroup_role"
             inverse="true"
             cascade="save-update">

                                        column="group_id"/>

hibernate.cfg.xml 同前面的例子差不多。

public class Test {

public static void main(String[] args) throws HibernateException {

  Role role1 = new Role();
  role1.setName("Role1");
  Role role2 = new Role();
  role2.setName("Role2");
  Role role3 = new Role();
  role3.setName("Role3");
  Group group1 = new Group();
  group1.setName("group1");
  Group group2 = new Group();
  group2.setName("group2");
  Group group3 = new Group();
  group3.setName("group3");
  group1.getRoles().add(role1);
  group1.getRoles().add(role2);
  group2.getRoles().add(role2);
  group2.getRoles().add(role3);
  group3.getRoles().add(role1);
  group3.getRoles().add(role3);
  role1.getGroups().add(group1);
  role1.getGroups().add(group3);
  role2.getGroups().add(group1);
  role2.getGroups().add(group2);
  role3.getGroups().add(group2);
  role3.getGroups().add(group3);

  SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
  Session session = sessionFactory.openSession();
  Transaction tx= session.beginTransaction();
  session.save(role1);
  session.save(role2);
  session.save(role3);
  session.save(group1);
  session.save(group2);
  session.save(group3);
  tx.commit();
  session.close();
  sessionFactory.close();
}
}

天边一片伴月星 2006-10-31 15:47 发表评论

用cocoon call webservice 生成 html，excel

天边一片伴月星 — Wed, 18 Oct 2006 02:11:00 GMT

xsp 代码

xmlns:xsp="http://apache.org/xsp"
xmlns:xsp-request="http://apache.org/xsp/request/2.0"
xmlns:xscript="http://apache.org/xsp/xscript/1.0"
xmlns:soap="http://apache.org/xsp/soap/3.0" >

       String cFCType= request.getParameter("cFCType");
       String cPFrom= request.getParameter("cPFrom");

        iStartYear

   http://gpaukwsa.gpe-hkg.com:8080/wsa/wsa1">


     http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="cFCTypehttp://www.w3.org/2001/XMLSchema">cFCType>
     http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="cPFromhttp://www.w3.org/2001/XMLSchema">cPFrom>

xml2html 代码

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:sql="http://apache.org/cocoon/SQL/2.0">

https://www.gpacoustics.com/ctrl/ukweb/forecast/images/uklogo.jpg" width="120" height="60">

Forecast Report

Part No	Description

xml2xls 代码

http://www.w3.org/1999/XSL/Transform"
                              xmlns:sql="http://apache.org/cocoon/SQL/2.0"
                             xmlns:gmr="http://www.gnome.org/gnumeric/v7" >

http://www.gnome.org/gnumeric/v7">

        Sheet 1



          Sheet 1

                                        Shade="0" Indent="0" Locked="1" Hidden="0"
                         Fore="0:0:0" Back="FFFF:FFFF:FFFF"
                         PatternColor="0:0:0" Format="General">

                  Helvetica

      Part No
  Description

天边一片伴月星 2006-10-18 10:11 发表评论