villa123/
共617个网摘 [
1 2 3 4 5 6 ...
21 ]
下一页 |
访问villa123的个人空间
villa123收录，使用标签：Java，时间：2008-10-10 13:59:11 | 相关网摘，我也收藏
mengweilil：MyEclipse
优点：因为专心J2EE方面的项目，所以不需要Swing支持。MyEclipse在UML、Struts、Hibernate方面都还可以，而且也不是很贵，万一有朝一日不得不正版的时候，也还买得起。
缺点：DB管理方面，实体类映射方面，PowerDesigner的地位始终无法替代。其他很多支持UML的工具，但都要收费。
Landor2004：
eclipse：现在的eclipse也相当好用，附带的插件也已经很齐全，我们主要适用这个
netbean：我比较喜欢netbean的代码辅助能力，从后台代码，到前台表单提示，应有尽有；我最喜欢的还是or映射的自动生成，我一般都是用netbean来生成映射，再拷贝到eclipse里，虽然有些麻烦，不过习惯了！
joejoe1991：jbuilder 2006
原因是代码提示功能强.很人性化.准确地说是很符合我的习惯.无论是从界面风格还是字体颜色,都是我比较喜欢的那种,各种功能集成的也不错.用着方便.
第一眼见eclipse就觉得太难看了.而且代码提示功能太烂,一般我觉得不好看的软件我都不用..
microns：JDeveloper
集成的东西很多，用起来比较方便，因为我一般都是使用oracle数据
用ORACLE的JDeveloper更方便，不用像eclipse安装那么多插件，麻烦！
主要原因是学校和oracle公司有合作，捐赠了不少软件，所以我们学校都选的ORACLE的开发套件
todaydiy：
初学java的时候用的是jCreator,感觉蛮好的，很轻便。但是设计swing的时候，没有设计视图，所以一切都要靠手写代码来确定控件的位置。
再后来用的是Jbuilder,这个就可以很方便的开发j2ee了，但占用系统资源太多，并且那个时候害怕在里面打中文，一打中文就关了。好像可以设置的。
现在一直用的是myeclipse，比起前面的两种IDE方便多了，就是开发ejb有点麻烦。
……
http://topic.csdn.net/u/20081004/22/cd3980b0-8e57-40bf-92dc-22f65a491ab4.html
http://topic.csdn.net/u/20081004/22/cd3980b0-8e57-40bf-92dc-22f65a491ab4.html
villa123收录，使用标签：Java，时间：2008-10-9 17:06:51 | 相关网摘，我也收藏
Groovy探索之Map与DSL
在Java语言编程中，从Java5开始引入了可变参数的概念；引入可变参数的目的，是为了解决形如下面代码的编码冗余。
public class VarArgument {
private int a,b,c,d;
private void p()
{
System.out.println(a+","+b+","+c+","+d);
}
public void foo(int a)
{
this.a = a;
p();
}
public void foo(int a,int b)
{
this.a = a;
this.b = b;
p();
}
public void foo(int a,int b,int c)
{
this.a = a;
this.b = b;
this.c = c;
p();
}
public void foo(int a,int b,int c,int d)
{
this.a = a;
this.b = b;
this.c = c;
this.d = d;
p();
}
public static void main(String[] args) {
VarArgument va = new VarArgument();
va.foo(1,4);
}
}
上面的代码中，是一个面向对象编程中的常用的方法重载，目的是为了解决“foo”方法输入参数的个数是可以变化的问题，也就是可变参数的问题。我们可以看到，利用方法重载来解决可变参数的问题，我们需要写出多个方法来做同一件事情，这使得我们的编码效率大大降低。
为了提高编码效率，我们从Java5开始引入了可变参数的概念，通过可变参数上面的代码可以写成下面的样子：
public class VarArgument {
private int a,b,c,d;
public void foo(int... nums)
{
int len = nums.length;
if(len>0) a = nums[0];
if(len>1) b = nums[1];
if(len>2) c = nums[2];
if(len>3) d = nums[3];
//todo
System.out.println(a+","+b+","+c+","+d);
}
public static void main(String[] args) {
VarArgument va = new VarArgument();
va.foo(1,4);
}
}
可以看出，随着Java5引入的可变参数概念，的确使得我们的编码量大大减轻，使得我们朝着敏捷编程的方向在前进。但是，可变参数的引入，仍然有以下三个问题没有解决：一是，可读性的问题，作为VarArgument类的使用者，我们不知道“va.foo(1,4)”中的“1”和“4”代表的含义。二是，参数顺序的问题，比如我们想将1赋给a，4赋给b，当然只能严格写成“va.foo(1,4)”，而不能写成“va.foo(4,1)”。三是，灵活性不足，比如，我们只想给a赋值1，c赋值3，我们就得写成这样的“va.foo(1,0,3)”，而不能写成这样“va.foo(1,3)”。
为了解决上面的问题，我们在Groovy语言中来使用Map对象作为“foo”方法的参数，请看下面的示例：
class Testor4 {
private int a,b,c,d
def foo(Map map)
{
this.a = map['a']?map['a']:a
this.b = map['b']?map['b']:b
this.c = map['c']?map['c']:c
this.d = map['d']?map['d']:d
//todo
println "$a,$b,$c,$d"
}
static void main(args) {
def t = new Testor4()
t.foo([a:1,b:4])
}
}
可以看到，引入了Map作为参数，我们在Java编程中的可变参数所没有解决的三个问题都得到了解决。
你可能会说，这没有什么啊，Java语言也可以使用Map作为参数啊。是的，Java语言的确可以使用Map作为参数，但Groovy语言对Map参数所做的如下简化，就是Java语言所不及的了。
def t = new Testor4()
t.foo(a:1,b:4)
看到了吗？作为“foo”方法的使用者，我们可以完全不知道我们输入的参数是Map类型的，我们只知道把我需要给方法的两个参数a和b使用“t.foo(a:1,b:4)”的方式给方法；如果我们只想给a和c赋值，则可以使用这样的形式“t.foo(a:1,c:3)”。这真的是在可读性和敏捷性上大大提高。
看到了上面的代码，我们立刻会想起我们在GroovyBean中是如何初始化一个对象的。比如有如下一个GroovyBean：
class Person
{
String id
String name
String age
}
我们会使用如下的方式来初始化它：
def person = new Person(name:'Tom',age:23)
现在我们就可以知道其中的奥秘了。
正是因为在Groovy语言中使用Map对象作为输入参数大大增强了代码的可读性，我们把它作为DSL编程实现的一种方式。
下面，我们使用一个求两点之间的距离的方法来演示使用Map对象作为输入参数的DSL编程方式的例子。
class Testor5 {
def length(Map map)
{
def fx = map['x1']
def fy = map['y1']
def tx = map['x2']
def ty = map['y2']
return Math.sqrt((fx-tx)*(fx-tx)+(fy-ty)*(fy-ty))
}
static void main(args) {
def mc = new ExpandoMetaClass(Integer.class,true)
mc.getM <<
{
->
delegate as float
}
mc.getCm <<
{
->
def cm = delegate as float
cm/100
}
mc.initialize()
def t = new Testor5()
println t.length(x1:1.m,y1:200.cm,x2:4.m,y2:500.cm)
}
}
在上面的例子中，我们使用数学坐标来表达点，比如“x1:1.m,y1:200.cm”代表起点，而“1.m”代表1米的地方，“200.cm”代表200厘米。“x2:4.m,y2:500.cm”代表终点的坐标。这种表达法的可读性就非常强，对于“1.m”和“200.cm”这样的表达式，我们在《Groovy探索之运算符的重载 二》里详细的讲过，没看过的可以点击http://blog.csdn.net/hivon/archive/2008/07/15/2651693.aspx。
可以看到，“length(x1:1.m,y1:200.cm,x2:4.m,y2:500.cm)”用来表达两点（x1:1.m,y1:200.cm）和（x2:4.m,y2:500.cm）之间的距离，这样的可读性比较好，而且使用Map作为输入参数，实现起来也比较简单。
总之，在Groovy语言中使用Map作为输入参数，给我们带来编码的可读性，可以作为DSL的一种实现方式。
http://blog.csdn.net/hivon/archive/2008/10/07/3025552.aspx
villa123收录，使用标签：Java，时间：2008-10-6 17:39:30 | 相关网摘，我也收藏
2002年2月发布的JDK 1.4已经服役了6.5年，将于今年的10月20日正式进入官方服务周期的终结流程（officially enter End of Service Life －EOSL）。JDK 1.4是运行时间最长和最成功的JDK版本之一，它的出现为JDK带来了很多新的功能，比如assert, regex, NIO, exception chaining等，以及java logging……回忆JDK 1.4的发布宛如昨日，岁月如梭，JDK 1.4也走到了尽头。
officially enter End of Service Life－EOSL意味着什么呢？
EOSL是Sun的产品生命周期政策的一部分，意味着官方的免费支持和更新将停止，不再针对这个版本进行bug fix和patch更新。如果你需要继续支持，只能购买Sun的附加服务，Sun能提供另外10年的附加服务。
现在使用JDK 1.4版本的用户仍然很多，而明年10月JDK 1.5同样也会进入EOSL，所以要为JDK的版本更换做准备了……
http://www.cnbeta.com/articles/66326.htm
villa123收录，使用标签：Java，时间：2008-9-27 15:21:39 | 相关网摘，我也收藏
目前，JPA（Java Persistence API）的使用范围越来越广，作为Java EE 5.0平台标准的ORM规范，得到了诸如：Hibernate、TopLink、OpenJpa等ORM框架的支持，同时还是EJB 3.0的重要组成部分。JPA的宗旨是为POJO提供持久化标准规范。它能够脱离容器独立运行，方便开发和测试。本文将通过一个小实例来说明如何在Hibernate中使用JPA，来达到简化编程的目的。
开发环境 Eclipse 3.3.1 MyEclipse 6.0.1GA Tomcat 6.10 SQL Server 2000
hibernate-3.2.5.GA hibernate-annotations-3.3.0.GA
ejb3-persistence hibernate-commons-annotations-3.0.0.GA
本文是为后续的多种Ajax技术框架应用系列作一个前期准备，让大家先了解一下相比与以前的Hibernate ORM映射的不同之处，以及采用JPA所带来的好处。
为了保证程序能顺序运行，避免不同的Eclipse版本之间产生错误，大象强烈建议，下载源码后，按源码中的工程名，自己单独新建同一个工程，再将src和WEB-INF/lib目录下的所有文件COPY至对应的目录下。
1、创建Web Project
点击"File"->"New"，选择"Web Project"，在"Project Name"中输入ajax，点击"Finish"。下载本文后面需要用到的JAR包，加入到WEB-INF/lib目录下，在ajax工程中，文本采用的是UTF-8编码。
2、创建HibernateSessionFactory
传统的方法就是在工程名上点右键，选择”MyEclipse”->”Add Hibernate Capabilities”，然后就是按照提示一步一步做，不过在MyEclipse 6.0.1中添加Hibernate还是只能支持3.1，除非你选择” Add Spring Capabilities”，里面才有Hibernate 3.2的类库，要想完全兼容JPA，必须采用3.2以上版本。
这里大家直接使用源码中的HibernateSessionFactory，注意请先建包：com.ajax.core,HibernateSessionFactory中有一个地方需要改动，原来的写法是：
private static Configuration configuration = new Configuration(); 修改后为：
private static AnnotationConfiguration configuration = new AnnotationConfiguration(); 因为我们采用的是JPA注释方式来映射实体，另外AnnotationConfiguration这个类在hibernate-annotations.jar这个包中。
3、创建BaseDao
在com.ajax.core包下面新建BaseDao抽象类，里面定义的是持久化操作方法，有一点特别要注意，一定要在增加、删除、修改这几个方法中加入事务控制，不管是在BaseDao基类方法中加，还是在业务方法中加，一定要加事务控制，大象觉得在基类中加会比较好一点，这样做代码显得更少更简洁。如果不加事务控制，那么增、删、改这些操作都不会产生效果，因为默认情况下，它不会进行自动提交。在做这个例子的时候，这个问题曾经困扰了我好长时间。因此，请大家记住不要再犯和大象一样的错误！贴出部分代码，详情请看源码，里面有很全面的注释。
/**
* 抽象Dao类，用于持久化操作
* @author 菠萝大象
* @version 1.0
*/
public abstract class BaseDao {
private static Log log = LogFactory.getLog(BaseDao.class);
/**
* 获取Hibernate的Session对象
*/
public Session getSession(){
return HibernateSessionFactory.getSession();
}
/**
* 根据主键得到对象
*/
public T getObject(Class clazz, Serializable id){
return (T)getSession().get(clazz, id);
}
/**
* 保存对象
*/
public void saveObject(T t) {
Session session = getSession();
Transaction tx = beginTransaction(session);
try{
session.saveOrUpdate(t);
tx.commit();
}catch(Exception e){
tx.rollback();
log.error("保存对象失败");
}
}
/**
* 创建事务
*/
private Transaction beginTransaction(Session session){
return session.beginTransaction();
}
} 4、创建Employee
在com.ajax.employee.mode包下新建Employee类，这个就是POJO类，下面来详细说明里面的含义。
@Entity
@Table(name = "EMPLOYEE")
public class Employee implements java.io.Serializable{
private Integer employee_id; //人员ID（主键）
private String employee_name; //人员姓名
private String sex; //性别
private String birthday; //出生日期
private String address; //地址
@Id
@Column(name = "EMPLOYEE_ID")
@TableGenerator(
name="tab-store",
table="GENERATOR_TABLE",
pkColumnName = "G_KEY",
pkColumnValue="EMPLOYEE_PK",
valueColumnName = "G_VALUE",
allocationSize=1
)
@GeneratedValue(strategy = GenerationType.TABLE,generator="tab-store")
public Integer getEmployee_id() {
return employee_id;
}
public void setEmployee_id(Integer employee_id) {
this.employee_id = employee_id;
}
} 其它几个属性的getter和setter省略，这里我们要用到ejb3-persistence.jar，JPA的注解类就在这个包中，下面详细说明上面使用到的注解。
@Entity：通过@Entity注解将一个类声明为一个实体bean
@Table：通过 @Table注解可以为实体bean映射指定表，name属性表示实体所对应表的名称，如果没有定义 @Table，那么系统自动使用默认值：实体的类名（不带包名）
@Id：用于标记属性的主键
@Column：表示持久化属性所映射表中的字段，如果属性名与表中的字段名相同，则可以省略@Column注解，另外有两种方式标记，一是放在属性前，另一种是放在getter方法前，例如：
@Column(name = "EMPLOYEE_NAME")
private String employee_name; 或者
@Column(name = "EMPLOYEE_NAME")
public String getEmployee_name() {
return employee_name;
} 这两种方式都是正解的，根据个人喜好来选择。大象偏向于第二种，并且喜欢将属性名与字段名设成一样的，这样可以省掉@Column注解，使代码更简洁。
@TableGenerator：表生成器，将当前主键的值单独保存到一个数据库表中，主键的值每次都是从指定的表中查询来获得，这种生成主键的方式是很常用的。这种方法生成主键的策略可以适用于任何数据库，不必担心不同数据库不兼容造成的问题。大象推荐这种方式管理主键，很方便，集中式管理表的主键，而且更换数据库不会造成很大的问题。各属性含义如下：
name：表示该表主键生成策略的名称，这个名字可以自定义，它被引用在@GeneratedValue中设置的"generator"值中
table：表示表生成策略所持久化的表名，说简单点就是一个管理其它表主键的表，本例中，这个表名为GENERATOR_TABLE
pkColumnName：表生成器中的列名，用来存放其它表的主键键名，这个列名是与表中的字段对应的
pkColumnValue：实体表所对应到生成器表中的主键名，这个键名是可以自定义滴
valueColumnName：表生成器中的列名，实体表主键的下一个值，假设EMPLOYEE表中的EMPLOYEE_ID最大为2，那么此时，生成器表中与实体表主键对应的键名值则为3
allocationSize：表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50
@GeneratedValue：定义主键生成策略，这里因为使用的是TableGenerator，所以，主键的生成策略为GenerationType.TABLE，生成主键策略的名称则为前面定义的”tab-store”。
这里大象想说下，网上有很多文章写的是strategy = GenerationType.AUTO或是strategy = GenerationType.SEQUENCE，采用SEQUENCE序列是因为Oracle数据中不支持identity自动增长，要想使用它，还得在数据库中创建一个序列，如果要更换数据库，那将是一个非常麻烦的事情。SEQUENCE生成方式我们暂且不谈，这里说下采用AUTO和IDENTITY的生成方式，本例采用的是SQL Server 2000作为数据库，所以如果想使用AUTO或是IDENTITY生成策略，则一定要对主键加上identity标识，如identity(1,1)。不过对于AUTO来说，是根据不同的数据库选择最合适的自增主键生成策略。如果使用MySQL，则主键要定义AUTO_INCREMENT，如果是Oracle，则要创建Sequence来实现自增。不管采用何种生成策略，增、删、改这些方法中一定要加入事务，否则数据是不会添加到数据库中滴~~~这是大象反复测试过的结果！
5、创建数据库及表
接下来，我们需要为本例创建一个数据库及必要的表。数据库名为ajax，表只有两个EMPLOYEE和GENERATOR_TABLE，下面是SQL脚本：
CREATE TABLE EMPLOYEE(
EMPLOYEE_ID int not null,
EMPLOYEE_NAME varchar (20) null,
SEX char (2) null,
BIRTHDAY varchar(10) null,
ADDRESS varchar(50) null,
CONSTRAINT PK_EMPLOYEE PRIMARY KEY (EMPLOYEE_ID)
)
CREATE TABLE GENERATOR_TABLE(
ID int not null,
G_KEY varchar(20) null,
G_VALUE int null,
CONSTRAINT PK_GENERATOR_TABLE PRIMARY KEY (ID)
)
INSERT INTO GENERATOR_TABLE VALUES(1,EMPLOYEE_PK,1) 如果你觉得麻烦，不想建库及表，可以将后面的数据库下载下来，然后还原数据库就可以了。
6、修改hibernate.cfg.xml
本例中，采用的是JTDS连接驱动，我们要对配置文件作一些设置，另外还要加入POJO类。
org.hibernate.dialect.SQLServerDialect
net.sourceforge.jtds.jdbc.Driver
jdbc:jtds:sqlserver://localhost:1433/ajax
sa
自己密码(无密码就空着)
以前没有使用JPA注解的时候，我们这里加入的都是hbm.xml文件，现在我们则加入的是类。
7、创建EmployeeManager
在com.ajax.employee.service下新建EmployeeManager类，这里面就是写业务方法，另外在这个类中添加一个main方法用于测试，将log4j的日志级别调整为DEBUG，这样我们就可以看到很详细的程序运行信息，源码中的注释很详细，这里就不贴出来了。
本例没有提供MySQL和Oracle数据库的脚本，不过这些应该很简单，按照最基本的方式建一个数据库和两张表就行了，这里附上两种数据库的hibernate配置。
MySQL：
org.hibernate.dialect.MySQLInnoDBDialect
com.mysql.jdbc.Driver
jdbc:mysql://localhost:3306/ajax
root
自己的密码(无密码就空着) Oracle：
org.hibernate.dialect.OracleDialect
oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:@127.0.0.1:1521:自己的SID
system
自己的密码(无密码就空着) 本文主要是从实用的角度来说明如何在Hibernate中使用JPA注释来简化开发，以及为后面的多种Ajax技术框架应用系列作一个前期准备。从这里可以看出，我们不需要再编写繁琐的hbm.xml文件。另外，JPA的功能很强大，这里只展示了其中的冰山一角，如果想深入学习JPA的话，请单独查找资料或购买相关书籍。
下面是本例中必须的JAR包
点击下载：antlr-2.7.6 asm-1.5.3 cglib-2.1.3 commons-collections-2.1.1 commons-lang-2.1
commons-logging-1.0.4 log4j-1.2.14 ehcache-1.2.3 ejb3-persistence-3.0
hibernate3-3.2.5 hibernate-annotations-3.3.0 hibernate-commons-annotations-3.0.0
mysql-connector.jar jtds.jar classes12.jar
点击下载：ajax_project db_ajax
本文为菠萝大象原创，如要转载请注明出处。
http://www.blogjava.net/bolo/archive/2008/09/19/229823.html
villa123收录，使用标签：Java，时间：2008-9-27 11:06:14 | 相关网摘，我也收藏
NetBeans.org由Sun公司在2000年创立,它是开放源运动以及开发人员和客户社区的家园,旨在构建世界级的Java IDE.NetBeans 6.5 带来很多新的特性,想尝鲜的朋友可以到官方网站上下载了!这个不是最终版,大家可以尝试一下,说不定你就会喜欢上他的.下面是NetBeans 6.5 中新增的特性以及增强的功能一览表:
http://wiki.netbeans.org/NewAndNoteWorthyMilestone1NB65
http://wiki.netbeans.org/NewAndNoteWorthyMilestone2NB65
NetBeans IDE Build 200809251401 下载
http://bits.netbeans.org/download/trunk/nightly/latest/ml/?pagelang=zh_CN
http://www.cnbeta.com/articles/65730.htm
villa123收录，使用标签：Java，时间：2008-9-26 14:59:21 | 相关网摘，我也收藏
【CSDN编译】最近，人们在思考如何使用Java来实现云计算，我看到了两种趋势性的方法。它们存在交叉重叠处而并非互相排斥，但总体而言它们在项目方面有着非常不同的表现：
重面向UI（Heavy UI oriented）
这种类型的应用或框架通常提供基于UI的控制台、管理有用、插件等，这为管理云中的资源比如开始和停止图像等提供了唯一的方法。这种方法的关键特征是它需要大量用户的输入和人的干预，所以这变得相对不动态、不随需而变。最好的例子是：RightScale, GigaSpaces, ElasticGrid。
重面向框架（Heavy framework oriented）
这种方法非常强调云中资源管理的动态性。其关键特征是它不需要用户的输入和人的干预，所以的资源管理可以通过grid/cloud中间件来程序化地完成。Google App Engine (for Python), GridGain就是这方面最好的例子。
现在，我们可以轻易地看到两种方法的各自好处。传统的计算环境中，网络和系统管理员管理云（传统的数据中心也是这么管理的），开发者对它有很少的控制，因而第一种方法对此非常有效。
就像我说的，第二种方法听起来有些新颖和现代。它的目的是，通过提供相对定位的透明度来扫除本地工作站与云（内部或外部的）之间的障碍，从而开发者写代码、建立并运行可以通过完全一样的方法，而不必在乎这些工作是在本地工作站还是几千公里外的云上还是这二者一起完成的。
http://news.csdn.net/n/20080926/119450.html
villa123收录，使用标签：Java，时间：2008-9-25 15:43:13 | 相关网摘，我也收藏
9月23日消息，Jar中的Bliki是一个用Java语言编写的Wiki，主要支持Wikipedia语法。它的目的是运行在一个U盘代替一份文件笔记本电脑，像个人信息管理器（ PIM ）。
下载：
最新版本下载：BlikiInAJar-3.0.9.zip
配置
在window下运行 开始-cmd ，linux下 开始-sh文件，你可以通过改变 -Duser.language=XX命令选项设置wiki的默认语言。例如：
-Duser.language=de
目前Bliki支持Wikipedia命名空间内的一下语言：
en-english；
de-german；
fr-french；
es-spanish；
http://news.csdn.net/n/20080925/119405.html
villa123收录，使用标签：Java，时间：2008-9-25 15:42:29 | 相关网摘，我也收藏
9月24日消息，SE/EE执行委员批准了JSR 311 JAX-RS作为支持RESTful web服务的java 应用程序接口。JAX-RS (Java平台上的REST支持规范 - aka JSR-311) 成为第一个到达提议为最终草案阶段的JavaEE 6的规范。
查看Java规范需求点击：http://jcp.org/en/jsr/detail?id=311
与JSR-311更多相关内容：http://jcp.org/en/jsr/detail?id=311
http://news.csdn.net/n/20080925/119406.html
villa123收录，使用标签：Java，时间：2008-9-25 15:41:35 | 相关网摘，我也收藏
9月24日消息，NetBeans IDE “手机之家”每周做一次检查更新。Sun根据捕捉到的统计数据确定活跃使用者的数量及他们来自哪里。以下是过去一年内，前20个国家使用NetBeans任意版本的统计数据。
1. # Country Count Ratio
2. 1. United States 373,252 16.1%
3. 2. Brazil 204,470 8.8%
4. 3. India 142,460 6.1%
5. 4. Germany 120,482 5.2%
6. 5. China 117,489 5.1%
7. 6. Mexico 88,320 3.8%
8. 7. United Kingdom 79,847 3.4%
9. 8. Spain 78,408 3.4%
10. 9. Italy 65,798 2.8%
11. 10. France 59,191 2.5%
12. 11. Poland 57,076 2.5%
13. 12. Canada 49,666 2.1%
14. 13. Colombia 42,970 1.8%
15. 14. Japan 40,883 1.8%
16. 15. Peru 37,230 1.6%
17. 16. Czech Republic 32,763 1.4%
18. 17. Russian Federation 29,765 1.3%
19. 18. Australia 27,992 1.2%
20. 19. Thailand 27,975 1.2%
21. 20. Netherlands 24,551 1.1%
# Country Count Ratio 1. United States 373,252 16.1% 2. Brazil 204,470 8.8% 3. India 142,460 6.1% 4. Germany 120,482 5.2% 5. China 117,489 5.1% 6. Mexico 88,320 3.8% 7. United Kingdom 79,847 3.4% 8. Spain 78,408 3.4% 9. Italy 65,798 2.8% 10. France 59,191 2.5% 11. Poland 57,076 2.5% 12. Canada 49,666 2.1% 13. Colombia 42,970 1.8% 14. Japan 40,883 1.8% 15. Peru 37,230 1.6% 16. Czech Republic 32,763 1.4% 17. Russian Federation 29,765 1.3% 18. Australia 27,992 1.2% 19. Thailand 27,975 1.2% 20. Netherlands 24,551 1.1%
(source: NetBeans DreamTeam mailing list Sep 9 2008)
在JavaOne2007大会上，Sun表示有300，000活跃的NetBeans用户。从6.0和6.1版本发布后，NetBeans IDE插件的使用者飞快增长。由此可以看出，大规模的NetBeans IDE用户群正在不断的扩大，商用和开源插件开发者应该大展拳脚，开发出更多更好的应用插件，有时我找到的IDE插件仅仅是对Eclipse和IntelliJ有用，NetBeans IDE插件有一个广阔的发展市场
http://news.csdn.net/n/20080925/119408.html
villa123收录，使用标签：Java，时间：2008-9-23 14:00:08 | 相关网摘，我也收藏
据国外媒体报道，21日消息，JaValid1.1版本发布。
JaValid是一个基于标注的验证框架，它允许用户标注Java类来引入验证。JaValid可以应用于任何类型的Java应用程序（独立应用程序，web应用程序等）。目前该框架提供与Spring框架、Java Server Faces、Facelets及任何数据库的完美集成。此框架容易扩展，有了扩展，你就可以在框架装载的验证之上，添加自己的验证约束。
1.1版本最重要的添加与修改如下：
*扩展，你可以添加自己的扩展到JaValid。这样你就可以添加所需的任何类型的验证（如webservices）。
*数据库扩展。这是一个新的扩展，允许你检查数据库中的约束。（例如，检查一个命名是否已经存在）
*在调用validateObject()的时候，添加可选的JavalidValidationCallbackHandler，允许你在验证之前或之后定制用户化验证。
*添加复数标注。从现在开始，所有已有和新的标注都允许复数类型（如，@MinLengths (values=@MinLenght(..),@MinLength}）
*添加@DateCheck标注
*JSF验证标签现在支持域验证
http://news.csdn.net/n/20080923/119303.html
villa123收录，使用标签：Java，时间：2008-9-22 15:14:19 | 相关网摘，我也收藏
JPPF是一个开放源码的网格计算框架,它可以在一个分布执行环境中 同时运行多个java应用。
新版本的改进之处：
作业可以从现有的代码中使用注释来定义
定义新的，简化的API并提交任务编译
服务器中离线事务的数量减少，便于管理
具有多个安全漏洞补丁，阻止运行服务节点。
多个JPPF屏幕保护程序补丁
JPPF的突出特性
提供了负载平衡，故障转移和错误恢复等服务。
提供一个基 于JMX的管理控制台，它既可以监视节点也可以管理执行的任务。你可以远程取消和重启任务，或配置令其超时的截止日期或时间间隔。
JPPF框架使用一个兼容JCA 1.5规范的资源适配器与J2EE应用服务器进行集成，这个适配器为服务器提供了到原始网格服务的访问。适配器通过实现异步任务提交从而避免了JTA事务超时的风险。
JPPF支持以下的应用服务器：
JBoss
Sun Application Server
Oracle OC4J
WebSphere
WebLogic
http://news.csdn.net/n/20080922/119240.html
villa123收录，使用标签：Java，时间：2008-9-22 15:13:36 | 相关网摘，我也收藏
ModuleFusion的目标是为了帮助程序员使用OSGi服务平台作为他们基本的运行环境。ModuleFusion包含了完整的Java企业应用的堆栈。目前这些堆栈包括同类最佳的Java生态系统开源框架。ModuleFusion不依赖于OSGi框架所提供的一些专有功能。
此外， ModuleFusion有可能建立正式的Java企业应用。
内容如下：
The Content:
* OSGi Service Platform
- OSGi Framework (Equinox or Felix)
- Configuration Admin
- User Admin
* Frameworks
- Google Guice IoC framework
- Apache Wicket
- Hibernate
- Hibernate JPA frontend
- Jetty web server
- HSQLDB database
- PAX web + extender bundle
* ModuleFusion
- DirInstaller (easily install/update/remove bundles and configurations)
- JPA integration
- Apache Wicket integration
* Logging
- Simple Logging Fassade for Java (SLF4J)
- Apache log4j
- SLF4J - log4j bridge
- Commons logging - SLF4J bridge
http://news.csdn.net/n/20080922/119242.html
villa123收录，使用标签：Java，时间：2008-9-22 15:13:09 | 相关网摘，我也收藏
据国外媒体报道，9月20日消息，iBatis for Java 2.3.4正式 发布。新版本对2.3.3版本修正了3个Bug，修正的错误和新版本的改进如下：
Bug
[IBATIS-244] - CLONE -configured type handler not used in insert
[IBATIS-512] - specifying custom boolean typehandler doesn't include primitives
[IBATIS-522] - NPE in TypeHandlerFactory.getTypeHandler() when type is null
Improvement
[IBATIS-511] - result to bean mapping: value should be included in exception message [patch included]
[IBATIS-515] - Element comments for DTDs
[IBATIS-534] - jdbc NULL to java int throw NullPointerException
http://news.csdn.net/n/20080922/119249.html
villa123收录，使用标签：Java，时间：2008-9-18 15:26:22 | 相关网摘，我也收藏
Spring Security 2.0是为Spring框架开发的下一代安全系统。在其上一代Acegi安全系统的基础上又添加了一些新特征。
现在存在的问题是如何让Spring Security 2.0与ZK Ajax框架共同工作，这篇文章就给出了一个如何让它们共同工作的例子。
最初，Spring框架下的Acegi安全系统为使用Spring框架开发的企业应用程序提供有力和灵活的安全解决方案。它是一个稳定、成熟的产品——Acegi Security 1.0.0发布于2006年5月，是在大型产品软件工程中使用了两年半之后发布的，并作为一个官方Spring子工程发布。
http://news.csdn.net/n/20080918/119157.html
villa123收录，使用标签：Java，时间：2008-9-18 15:25:59 | 相关网摘，我也收藏
Apache Solr组很高兴地宣布Solr 1.3.0开始提供下载使用。此版本继续对功能有所加强，同时修改了之前的一些bug，包括：
——分布式搜索性能
——许多Lucene和其他性能的改进
——支持在单个部署中的多级索引
——SolrJ客户端和一个二元响应协议，支持更快的客户端-服务器通信
——搜索组件可以被组成链式结构，用来提供更灵活的查询处理。组件包括现有的功能如faceting（多侧面搜索），同时添加More Like This（更多类似的）, Editorial Boosting (Query Elevation查询扩展) 和Spell Checking（拼写检查）。
——为了更容易索引数据库内容到Solr，建立新的DataImportHandler。
查看http://svn.apache.org/repos/asf/lucene/solr/tags/release-1.3.0/CHANGES.txt获取更多信息。
关于Apache Solr：
Solr是一个基于Lucene Java搜索库的开源企业搜索服务器，拥有XML/HTTP和JSON APIs，点击高亮显示，多侧面搜索，缓存，复制，web管理接口以及其他很多特征。可运行在如Tomcat之类的Java servlet容器上。
http://news.csdn.net/n/20080918/119156.html
villa123收录，使用标签：Java，时间：2008-9-17 11:18:39 | 相关网摘，我也收藏
Sun公司（Sun Microsystems）为了争夺开源代码开发群体，专门开设了一个名叫Kenai（发音为Keen-Eye）开源代码共享社区网站，此举的目的显而易见是为了从Google Code以及类似大名鼎鼎的SourceForge的网站拉拢一部分用户到自己的旗下。
也许是在beta期不吸引竞争对手太多的吸引力,Sun在上周五低调的开通了这个网站.类似Google Code和Sourceforge,开源开发者们可以将自己的项目代码、文档保存在这个网站上并使用网站提供的Subversion/Mercurial 版本控制服务.
自认为已经是地球上最大的开源公司的Sun,希望把这个网站打造成一个超出一个Forge网站的概念,而是对不断增长的开源社区的一个巨大支持. Kenai同时还把竞争对手锁定在了由Linus亲自领队开发的Git这个越来越流行的版本控制软件项目上.Linuxeden小编认为这是一个Sun精心策划的由控制开源团队到控制软件开发流程以及代码的美丽大蛋糕,但是开源社区是否愿意去品尝,那就让我们拭目以待吧.
Git --- The stupid content tracker, 傻瓜内容跟踪器.Linus 是这样给我们介绍 Git 的.
Git 是用于 Linux 内核开发的版本控制工具.与常用的版本控制工具 CVS, Subversion 等不同,它采用了分布式版本库的方式,不必服务器端软件支持,使源代码的发布和交流极其方便. Git 的速度很快,这对于诸如 Linux kernel 这样的大项目来说自然很重要. Git 最为出色的是它的合并跟踪(merge tracing)能力.
实际上内核开发团队决 定开始开发和使用 Git 来作为内核开发的版本控制系统的时候,世界开源社群的反对声音不少,最大的理由是 Git 太艰涩难懂,从 Git 的内部工作机制来说,的确是这样.但是随着开发的深入,Git 的正常使用都由一些友好的脚本命令来执行,使 Git 变得非常好用,即使是用来管理我们自己的开发项目,Git 都是一个友好,有力的工具.现在,越来越多的著名项目采用 Git 来管理项目开发,例如:wine, U-boot 等,详情看 http://www.kernel.org/git
Kenai网站:http://projectkenai.com/
Google code: http://code.google.com/
sourceforge: http://www.sf.net
http://www.cnbeta.com/articles/64857.htm
villa123收录，使用标签：Java，时间：2008-9-17 11:18:09 | 相关网摘，我也收藏
据国外媒体报道，Sun公司于9月15日发布企业级栈。Sun公司的AMP (Apache, MySQL, PHP/PERL) Web栈将运行在Solaris和Linux上，计划明年会运行在其他操作系统上。
Web栈包含网络和代理服务器，脚本语言和让开发人员快速简单部署Web应用程序的数据库。协议栈的主要组件涵盖了Apache HTTP Web服务器2.2.8版本，Apache Modules Memcached 1.2.5 (分布式内存对象系统), MySQL 5.1 版本数据库，lighttpd Web 服务器版本1.4.18, Tomcat Servlet 引擎6.0.16, PHP 5.2.5, Ruby 1.8.6, Rails 1.2.3, RubyGems 0.9.0, Mongrel 1.0.1, fcgi 包, RedCloth (文本解析), Perl 5.8.8 和扩展版本, Squid 代理服务器2.16.x.
Sun还将提供跨越多个操作系统的Web栈，使开发的应用程经过细小的变化就可部署在其他操作系统上。
http://news.csdn.net/n/20080916/119045.html
villa123收录，使用标签：Java，时间：2008-9-17 11:16:51 | 相关网摘，我也收藏
【CSDN编译】ZK在2008年9月15日宣告发布ZK Studio 0.8.2版。为其不断添加新特征，同时改进在其他平台上的兼容性，如Eclipse 3.4 Ganymede。
ZK Studio提供内容帮助，超链接高亮现实，彩色语法，以及其他让人兴奋的特征。ZK Studio是开始开发ZK应用程序所选择的最有效的方式。
请查阅ZK Studio安装向导来获得快速指南。
一段视频短片演示了ZK Studio的强大功能。
有关新特征的更多信息，请查阅新特征。
ZK简介
ZK 是一个基于XUL嵌入AJAX事件驱动的Java 框架，用于丰富用户网络应用程序界面，包括一个基于AJAX可自动进行交互式操作的事件驱动引擎和一套兼容XUL的组件.利用直观的事件驱动模型，你可以用具有XUL特性的组件来表示你的应用程序并通过由用户触发的监听事件来操作这些组件,就像开发桌面应用程序一样简单。
http://news.csdn.net/n/20080917/119097.html
villa123收录，使用标签：Java，时间：2008-9-17 11:11:13 | 相关网摘，我也收藏
【CSDN编译】最近我从Java转向了使用C#，这让我绞尽脑汁，摸索它们的不同之处。不要认为我做的不对——它们确实很相似，但一些关键语法和逻辑上的差别还是使这两种语言有明显的区别。下面列出我所发现的10大不同之处，与大家分享。详细查看原文：http://crfdesign.net/programming/top-10-differences-between-java-and-c
10、标准输出
9、命名空间
8、super关键字
7、从链式构造函数到基础构造函数
6、继承
5、静态变量constant的定义法
4、ArrayList，Vector，Hashtable类不复存在
3、访问器（Accessors——Getters）和修改器（Mutators——Setters）的不同
2、重载
1、关于类的理解
http://news.csdn.net/n/20080917/119109.html
villa123收录，使用标签：Java，时间：2008-9-16 19:45:15 | 相关网摘，我也收藏
原文地址：http://www.java2000.net/p9751
JDK地址：http://www.java2000.net/doc/jdk6_cn/java/lang/ProcessBuilder.html
一、JDK中的介绍摘录
此类用于创建操作系统进程。
每个 ProcessBuilder 实例管理一个进程属性集。start() 方法利用这些属性创建一个新的 Process 实例。start() 方法可以从同一实例重复调用，以利用相同的或相关的属性创建新的子进程。
每个进程生成器管理这些进程属性：
* 命令
是一个字符串列表，它表示要调用的外部程序文件及其参数（如果有）。在此，表示有效的操作系统命令的字符串列表是依赖于系统的。例如，每一个总体变量，通常都要成为此列表中的元素，但有一些操作系统，希望程序能自己标记命令行字符串——在这种系统中，Java 实现可能需要命令确切地包含这两个元素。
* 环境
是从变量 到值 的依赖于系统的映射。初始值是当前进程环境的一个副本（请参阅 System.getenv()）。
* 工作目录
默认值是当前进程的当前工作目录，通常根据系统属性 user.dir 来命名。
* redirectErrorStream 属性
最初，此属性为 false，意思是子进程的标准输出和错误输出被发送给两个独立的流，这些流可以通过Process.getInputStream() 和 Process.getErrorStream() 方法来访问。如果将值设置为 true，标准错误将与标准输出合并。这使得关联错误消息和相应的输出变得更容易。在此情况下，合并的数据可从 Process.getInputStream() 返回的流读取，而从 Process.getErrorStream() 返回的流读取将直接到达文件尾。
修改进程构建器的属性将影响后续由该对象的 start() 方法启动的进程，但从不会影响以前启动的进程或 Java 自身的进程。
大多数错误检查由 start() 方法执行。可以修改对象的状态，但这样 start() 将会失败。例如，将命令属性设置为一个空列表将不会抛出异常，除非包含了 start()。
注意，此类不是同步的。如果多个线程同时访问一个 ProcessBuilder，而其中至少一个线程从结构上修改了其中一个属性，它必须 保持外部同步。
很容易启动一个使用默认工作目录和环境的新进程：
Process p = new ProcessBuilder("myCommand", "myArg").start();
下面是一个利用修改过的工作目录和环境启动进程的例子：
ProcessBuilder pb = new ProcessBuilder("myCommand", "myArg1", "myArg2");
Map env = pb.environment();
env.put("VAR1", "myValue");
env.remove("OTHERVAR");
env.put("VAR2", env.get("VAR1") + "suffix");
pb.directory(new File("myDir"));
Process p = pb.start();
二、使用案例
使用Runtime的例子
package net.java2000.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
*
* @author 赵学庆，Java世纪网(java2000.net)
*
*/
public class TestRuntime {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("cmd /c dir",null,new File("e:/"));
InputStream is = process.getInputStream();
InputStreamReader isr = new InputStreamReader(is,"GBK");
BufferedReader br = new BufferedReader(isr);
String line;
System.out.printf("Output of running %s is:", Arrays.toString(args));
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
}
使用ProcessBuilder的例子
package net.java2000.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
/**
*
* @author 赵学庆，Java世纪网(java2000.net)
*
*/
public class TestProcessBuilder {
public static void main(String args[]) throws Exception {
ProcessBuilder builder = new ProcessBuilder("cmd", "/c", "dir");
builder.directory(new File("e:/"));
Process process = builder.start();
InputStream is = process.getInputStream();
InputStreamReader isr = new InputStreamReader(is, "GBK");
BufferedReader br = new BufferedReader(isr);
String line;
System.out.printf("Output of running %s is:", Arrays.toString(args));
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
}
总结：
ProcessBuilder为进程提供了更多的控制，例如，可以设置当前工作目录，还可以改变环境参数。而Process的功能相对来说简单的多。
ProcessBuilder是一个final类，有两个带参数的构造方法，你可以通过构造方法来直接创建ProcessBuilder的对象。而 Process是一个抽象类，一般都通过Runtime.exec()和ProcessBuilder.start()来间接创建其实例。
http://blog.csdn.net/java2000_net/archive/2008/09/15/2932305.aspx
villa123收录，使用标签：Java，时间：2008-9-12 18:11:03 | 相关网摘，我也收藏
有关另外一个WTP重要的数据模型IStructuredDocument已经在前面介绍过了，今天我们看一下另外一个核心的数据模型IStructuredModel。
在前面介绍IStructuredDocument的时候，我们知道IStructuredDocument的具体实现其实就是JFace Text Framework中IDocument接口的具体实现，其核心作用也集中在将特定文本按照特定的语法规则进行区域划分，提供相应的位置信息，这为WTP页面资源编辑器建立了核心数据模型。但是，单纯拥有偏重于语法的IStrucuturedDocument是不够的，我们同时还需要另外一套偏重于语义的数据模型，这就是IStructuredModel和其背后的WTP xml DOM实现（说明：对于CSS模型，是完全由WTP自己实现的，和本系列文章关系不大，本篇中不做详细介绍）。
注意：IStructuredModel以IStrucuturedDocument为基础构建，IStructuredDocument并不知道IStructuredModel，但是IStructuredModel知道该模型对应的IStrucuturedDocument！！！ 现在先大致猜测一下原因，如果是直接将特定页面资源的内容直接转换为IStructuredModel肯定不容易，因为我们页面资源中的内容往往不是那么规则，那转化的过程中肯定避免不了自己去做大量的解析，导致构建IStructuredModel构建过程异常复杂；如果利用已有的IStrucuturedDocument构建机制，先将特定的内容解析为IStrucuturedDocument完成语法划分，再基于高度结构化的IStrucuturedDocument去构建IStrucuturedModel，那肯定会大大简化构建过程，某种程度上就可以将构建过程理解为把IStrucuturedDocument中节点列表转换为IStrucuturedModel持有的Document对应的节点列表了。IStructuredModel构建过程大致示意如下：
【IStructuredModel：WTP Model句柄】
明天补充
【IndexedRegion：WTP Model的Node－Composite】
如果将IStructuredDocument视为WTP的语法模型，则可以将IStructuredModel视为WTP的语义模型，而这个语义模型的中节点的超类型则就是IndexedRegion（org.eclipse.wst.sse.core.internal.provisional.IndexedRegion）。首先来看一下IndexedRegion的类型体系图：
从上面的类型体系我们可以看的出来，IndexedRegion主要分为两类：一类是dom node（org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode），另一类是css node（org.eclipse.wst.css.core.internal.provisional.document.ICSSNode，这边用接口更舒服点^_^）。WTP在实现dom node系列时，借助于org.w3c.dom节点体系，这也是我们后面接触最多的；WTP在实现css node的时候，则和org.w3c.dom没有任何关系，完全是自己构建节点体系。
说明：WTP为什么要选择使用dom对象的xml实现呢，和我们通常的判断标准基本上一致的，因为需要较为丰富的语义。再者，一个页面资源的大小通常不会太大，也就是说一般不会产生非常巨大的DOM对象（例如大于10M）。
上面看了IndexedRegion主要分为两类，那么我们再回过头看一下IndexedRegion提供的核心操作：
我们看到IndexedRegion提供的核心操作都是关于位置信息的。这可能会产生一些疑问，例如位置信息的计算是不是挺繁琐的呢？怎么实现的呢？ 我们回顾一下前面在分析IStructuredDocument的时候，我们ITextRegion接口（IStructuredDocument中节点的超类型）提供的核心操作之一就是提供位置信息。如果我们的每个IndexRegion节点都持有相关的ITextRegion节点不就可以了？？？确实是这么做的。这和我们这篇文章开头说的是一直的，基于语义的IStructuredModel（实际上是构造背后的IDOMDocument和ICSSDocument）构建的基础是基于语法的IStructuredDocument。
那么现在如果我们有了位置信息（例如编辑器中的光标的offset），我们就可以把WTP Doucment中的ITextRegion和WTP Model中的IndexedRegion（IDOMNode、ICSSNode）联系起来了。
【IDOMNode：IndexRegion的XML DOM实现－Composite】
前面说过了，WTP model中的节点IndexedRegion有两种实现：一种是基于xml dom的IDOMNode，另外一种是WTP完全自己实现的ICSSNode，这里重点介绍IDOMNode（org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode）。
图中可以看的出来，我们的IDOMNode有两个超类型：IndexedRegion和org.w3c.dom.Node，我们的IDOMNode就提供了三类主要的操作：
1、IndexedRegion相关操作：提供位置相关信息的操作
2、org.w3c.dom.Node相关的操作：dom node相关操作（注意：有些dom node中规定的部分操作，WTP并没有实现）
3、IDOMNode提供的操作：明天接着写
http://www.blogjava.net/zhuxing/archive/2008/09/09/228006.html
villa123收录，使用标签：Java，时间：2008-9-12 18:09:57 | 相关网摘，我也收藏
Groovy 中提供了一个减少输入的特性叫做命名参数(Named Parameter)。GroovyBean 可以通过在构造器调用中传递冒号隔开的属性名称和值进行构建。如：
car = new Car(model : "BMW", color : "black");
car = new Car(model : "BMW", color : "black");
其实类似的用法早已有之，这有如 C++ 中的初始化成员列表，VB、Python、Transact-SQL 中的命名参数，JavaScript 中的 JSON 写法，Ruby 中提供的 syntax sugar用 hash 模拟所谓的 keyword argument。
我们先详细介绍 Groovy 的命名参数的用法与本质，然而再附上其他一些语言类似用法的实例，纵向贯通以加深印象。
要说从外部表现上好像是先调用了空构造方法，然后是相应的 setter 方法进行设值。因此，我们所直接想像的应该相当于下列 Java 代码
Car car = new Car();
car.setModel("BMW");
car.setColor("black");
Car car = new Car();
car.setModel("BMW");
car.setColor("black");
不过，假如你把 Groovy 生成的 class 文件反编译一下就会发现 Groovy 为上面那行生成了如下代码：
Class class1 = Car.class;
Class class2 = groovy.lang.MetaClass.class;
Car car = ((Car) (ScriptBytecodeAdapter.invokeNewN(class1, class1, ((Object) (new Object[] {
ScriptBytecodeAdapter.createMap(new Object[] {//Groovy 把命名参数转换成一个对象数组
"model", "BMW", "color", "black" //然后放到 Map 中，通过相应的 setter 方法或属性名反射赋值
})
})))));
Class class1 = Car.class;
Class class2 = groovy.lang.MetaClass.class;
Car car = ((Car) (ScriptBytecodeAdapter.invokeNewN(class1, class1, ((Object) (new Object[] {
ScriptBytecodeAdapter.createMap(new Object[] {//Groovy 把命名参数转换成一个对象数组
"model", "BMW", "color", "black" //然后放到 Map 中，通过相应的 setter 方法或属性名反射赋值
})
})))));
所以若再加以试验，就会知道那个 Car 必须要有一个空的构造方法，这是必要条件。但它们的属性值如果有相应的 setter 方法就用 setter 方法赋值，如果没有就直接通过反射进行设值。所以并不要求属性有相应的 setter 方法，甚至是私有属性而无相应的 setter 方法也不打紧。即使只有一个光头的 setter 方法，无对应属性也是可以的。－－有点啰嗦，觉得有用的话，可尽力去理解。
Groovy 是通过 org.codehaus.groovy.runtime.ScriptBytecodeAdapter 来完成这一过程的，看到 Bytecode 就知道它大概做了一些不光明的事情。
前面看到了，一行代码可以完成多行代码的功能。迫不急切地，我们还是来点有实效性的东西，例如构造一个 JFrame 窗口：
JFrame frame = new JFrame(
title:"Named Parameter",
size:[400,300],
location:new Point(300,200),
defaultCloseOperation:JFrame.EXIT_ON_CLOSE,
visible:true);
JFrame frame = new JFrame(
title:"Named Parameter",
size:[400,300],
location:new Point(300,200),
defaultCloseOperation:JFrame.EXIT_ON_CLOSE,
visible:true);
对上面那样一个过程，我们可以一句话说完，简洁易懂。要领就在于你只要发现可用的属性(不管是私有的还是别的)，或是 setXxx() 方法的那个 xxx (符合 JavaBean 规范即可) 就可以拿来作为命名参数的名字。
还应注意的是：在给 size 赋值时 size:[400,300] 使用到了隐式构造(Implicit constructors)，size 原本接收的是一个 Dimension，而实质 [400,300] 就是隐式的调用了 new Dimension(400,300)。所以 location 属性也可以写成 [300,200]。隐式构造还常用于 Builder 中，如 SwingBuilder。
命名参数不仅可以应用于构造实例时，还能运用于普通方法调用上，而且这种机制了可以接受 Map 对象作为参数的方法：
例如，前面的那么代码可以写成：
car = new Car(["model":"BMW","color":"black"]) //小注：在 GroovyEclipse 中最后那个中括号 "]" 的输入有点难度
car = new Car(["model":"BMW","color":"black"]) //小注：在 GroovyEclipse 中最后那个中括号 "]" 的输入有点难度
并且生成的字节码与原来完全一样，总之都是转换成对象数组，然后反射赋值。
再说一个接受 Map 参数的方法，以命名参数形式来调用的例子：
def desc(dog){
println dog.name;
println dog.breed;
}
def desc(dog){
println dog.name;
println dog.breed;
}
调用时可用以下两种形式，效果是完全一样的：
desc(name : "Lina", breed : "Labrador");
desc(["name" : "Lina", "breed" : "Labrador"]);
desc(name : "Lina", breed : "Labrador");
desc(["name" : "Lina", "breed" : "Labrador"]);
为有助于理解，还是反编译出以上两行生成的 Java 代码(都是一样的)：
Class class1 = Car.class;
Class class2 = groovy.lang.MetaClass.class;
ScriptBytecodeAdapter.invokeStaticMethodN(class1, class1, "desc", new Object[] {
ScriptBytecodeAdapter.createMap(new Object[] {
"name", "Lina", "breed", "Labrador" //不管怎么样，仍然是转换成对象数组，放到 Map 中，再逐个处理
})
});
Class class1 = Car.class;
Class class2 = groovy.lang.MetaClass.class;
ScriptBytecodeAdapter.invokeStaticMethodN(class1, class1, "desc", new Object[] {
ScriptBytecodeAdapter.createMap(new Object[] {
"name", "Lina", "breed", "Labrador" //不管怎么样，仍然是转换成对象数组，放到 Map 中，再逐个处理
})
});
用 Map 的形式只适用于键是字符串的情况。
前面例子中的属性值都是字符串，其实是可以接受任何的属性类型，例如：
car = new Car(manufactureDate: new Date(), height: 2); //假定 Car 有这两个属性
car = new Car(manufactureDate: new Date(), height: 2); //假定 Car 有这两个属性
注意：前面的代码以都是在 Groovy 1.5.6 版本中测验过，以及这一版本生成的字节码；可能其他版本生成的字节码略有不同，但执行结果应不会有差异。
附录：(对比其他几个语言的命名参数用法)
这里只是说类似，但是千万要注意 Groovy 的命名参数不能像 VB/Python/Transact-SQL 那样，调用方法时指示哪个参数是什么。Groovy 的命名参数是针对于类的属性(或者是 setter 方法)或 Map 的 Key。
1) C++ 的初始化成员列表：
Child::Child(char* surname):Parent(surname),name(10),height(20)
{ //surname 同时传递给父构造方法，并初始化成员变量 name 和 height
}; //似乎 C++ 的东西总是那么深不可测，这里只见识一下它的这一特性即可
Child::Child(char* surname):Parent(surname),name(10),height(20)
{ //surname 同时传递给父构造方法，并初始化成员变量 name 和 height
}; //似乎 C++ 的东西总是那么深不可测，这里只见识一下它的这一特性即可
2) VB 的命名参数：
Sub say(Optional code As String, Optional name As String)
MsgBox "Hello " & code
End Sub
Private Sub Command1_Click()
say code:="Unmi"
End Sub
Sub say(Optional code As String, Optional name As String)
MsgBox "Hello " & code
End Sub
Private Sub Command1_Click()
say code:="Unmi"
End Sub
3) Ruby 的做法：ruby 其实没有所谓的 keyword argument，而是提供一个syntax sugar用 hash 模拟。
def image(opt={})
default_opt = {:height => 25, :width => 10}
default_opt.merge! opt
#opt中同样key的內容会覆盖default_opt中key的value
end
def image(opt={})
default_opt = {:height => 25, :width => 10}
default_opt.merge! opt
#opt中同样key的內容会覆盖default_opt中key的value
end
4) Transact-SQL 中的命名参数：
my_proc @second = 2, @first = 1, @third = 3
my_proc @second = 2, @first = 1, @third = 3
其他像 Python、JavaScript 等各种语言的命名参数的用法就没必要继续列了。但据此我们能体验到这一特性确有其方便可取之处。
参考：1. 《Java 脚本编程，语言、框架与模式》第 4 章
2. 《Groovy in Action》第 7 章 Dynamic object orientation, Groovy style
3. C++初始化成员列表（member initialization list）
4. Ruby慣寫法
5. Python 使用可选参数和命名参数
http://www.blogjava.net/Unmi/archive/2008/09/09/227866.html
villa123收录，使用标签：Java，时间：2008-9-12 18:09:30 | 相关网摘，我也收藏
这个问题之所以没有答案，因为每个人看问题的角度不一样，给出的标准不一样，而又没有官方上的标准，在这里也是发表一下自己的看法，当然只是暂时的，或许明天这个答案又被自己否定了，希望能与各位多多交流，同时也希望各位多发表自己的意见。
java“高”手，这个高字我加了双引号，是在强调这个高字，而不是java初学者，也不是java大师，而是一个高手。
结合自己的目前的理解，谈谈自己的想法吧，分为以下几个方面：
1.JVM
包括以下几个方面：
熟悉jvm 规范
熟悉jvm内存管理机制
熟悉jvm classloader机制
能够编写下列工具：
反编译java代码工具
混淆java代码工具
jvm内存监控工具
字节码生成工具
2.开源框架
java相关的开源框架很多，在实际的项目开发中用到的也很多。
但是会使用并不能说明什么，仅仅能说明的是你对这个工具很熟悉，而且你也仅仅是把它当一个工具来看待。
如果你把他当作一个作品来看，你肯定不会仅仅从外面上来看。把她内脏挖出来，看看它的内部组成。
我的意思是说，你应该读读它的源代码，看看他的作者是怎样设计的，是怎样一步一步构思的。
把这些步骤都列出来，然后看看哪些地方是设计精妙所在，值得自己去进一步深思和挖掘。
你会感觉到你是在和一位大师沟通，他在指导着你，虽然你不能跟他见面。
经常看到很多简历上写着精通struts，精通hibernate等等，是不是真的精通呢？
问他问题：如果我让你来设计一个与struts，hibernate功能相同的框架，你会从哪些方面考虑？你会怎样设计？
还有人说精通java，那么在我看来你处在的层次就不仅仅是熟练使用它的api的级别上了，那么你一定会编写java的编译器吧？
3.设计能力
这方面是指你的oop的能力。
那么你是不是说我对设计模式很熟悉，那么我的设计能力水平就很高吗？不见得。
设计模式不过是给你提供了一系列的解决方案。
即使这些设计模式能解决你所有的问题，但是你还要去辨认何时使用模式合适，以及使用的过程当中 怎样去抽象一个问题，以及抽象到一个什么样的粒度。
有的人买来一本设计模式的书，按着上面的例子都运行了一遍，就自称熟悉设计模式。
教科书上的模式代码例子，也是一个类似hello world的例子而已。
设计模式不是一个简单的api调用，而是你的设计能力，绝非靠使用照着葫芦画瓢能达到的。
4 多线程
多线程的使用，必须熟练。
5.熟练使用java相关技术
在这里仅仅指j2ee方向的。
jms,jndi,ejb,webservice等等。
在这里不讨论数据库，软件工程等等，焦点仅限于java。当然前提是得懂java语法，而且对于jdk的api也能熟悉。
上述仅属于个人观点，欢迎你的讨论和指正，请不要人身攻击。
http://www.blogjava.net/jianggouben/archive/2008/09/05/java.html
villa123收录，使用标签：Java，时间：2008-9-12 18:09:05 | 相关网摘，我也收藏
jBPM 是一个非常优秀的开源工作流引擎，虽然他不是一个一站式的工作流平台，不过它已经为我们提供了比较丰富的底层操作，为了满足特定的项目需求，我们一般需要对其进行二次开发，才能适用于具体的业务需求。
其中一个主要的扩展点是针对 TaskNode 进行的用户的分配。TaskNode 是 jBPM 中一个非常重要的概念，一个任务节点可以包含若干个任务，不同的任务可以由不同的人来完成，任务实例被分配给 actorId 来完成，其中指定到人的分配工作就是 Assignment 要处理的，这也是我们需要定制的功能，为了实现用户的分配，我们需要实现 AssignmentHandler 接口，接口原型如下。
public interface AssignmentHandler extends Serializable {
void assign(Assignable assignable, ExecutionContext executionContext) throws Exception;
}
通常用代码实现的话，我们可以让一个类实现这个接口，并在 swimlane 或者 tasknode 中的 assignment 指定该类。但是，这样的灵活性是显然不够的，在系统的使用过程中，分配策略会不断的进行调整，因此我们需要更为灵活的解决方案，jBPM 本身可以使用基于 Bean Shell 的脚本来写分配策略，但是 Bean Shell 不是那么强大，我们需要更为强大的解决方案，因此，我们选用了已经被 JBoss 收为旗下的 JBoss Drools 4.0 规则引擎 (在 3.0 的时候曾经改名为 JBoss Rules，4.0 又改回来了)
jBPM 和 Drools 虽然同在 JBoss 旗下，不过他们目前并没有很好的进行整合，所以我们还是要利用它们系统系统的一些功能来做整合，同样也是实现 AssignmentHandler 接口，不过另外我们利用了 jBPM 里面的一个小小的技巧。看一下这段配置：
AgentAssignmentRule
红色标注的这段配置，我们可以理解为，在 RulesAssignmentHandler 这个类里有一个 ruleName 这样的属性，在初始化这个类的时候，jBPM 会把配置中 ruleName 的值 set 给 RulesAssignmentHandler 中 ruleName 的属性。
public class RulesAssignmentHandler implements AssignmentHandler {
protected String ruleName;
public String getRuleName() {
return ruleName;
}
public void setRuleName(String ruleName) {
this.ruleName = ruleName;
}
protected RuleBase readRule(String ruleName) throws Exception {
// 到 classes 下的 /rules 下加载相应的文件
String rulePath = "/rules/" + ruleName + ".drl";
Resource resource = new ClassPathResource(rulePath);
Reader reader = new InputStreamReader(resource.getInputStream());
PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(reader);
Package pkg = builder.getPackage();
RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage(pkg);
return ruleBase;
}
protected void initRuleContextData(ExecutionContext executionContext, WorkingMemory workingMemory) {
ContextInstance ci = executionContext.getContextInstance();
Map vars = ci.getVariables();
workingMemory.insert(ci);
workingMemory.insert(vars);
}
public void assign(Assignable assignable, ExecutionContext executionContext) throws Exception {
RuleBase ruleBase = readRule(ruleName);
WorkingMemory workingMemory = ruleBase.newStatefulSession();
// 为了简便操作，我只是拿了放入 ExecuteContext 中的 variable 进行逻辑处理
initRuleContextData(executionContext, workingMemory);
workingMemory.insert(assignable);
workingMemory.fireAllRules();
}
}
对应的 AgentAssignmentRule.drl 文件内容如下，假定 ExecutionContext 中有 price 这个 variable，我们判定当这个值 > 5000 的时候，我们将此任务分配给 senior_agent 来处理。
package org.agilejava.workflow
import java.util.Map
import org.jbpm.taskmgmt.exe.Assignable
rule "Assign Agent"
when
a : Assignable()
Map(this['price'] >= 5000)
then
a.setActorId("senior_agent");
end
就这样，我们就完成了最为简单的 jBPM 和 Drools 的整合，当然这种方式只是简单的利用了 jBPM 的一些特性来做的，我们每次都得指定这个 RulesAssignmentHandler，还是很麻烦的，更好的方式就是我们改写 ProcessDefinition.xml 的 parser，让 Drools 的规则定义成为和 swimlane, actor-id, expression 这样的分配方式同样级别的，让 Drools 成为 jBPM 的一等公民，这个以后研究好了再来和大家分享。
http://www.blogjava.net/steady/archive/2008/09/05/227236.html
villa123收录，使用标签：Java，时间：2008-9-12 18:08:17 | 相关网摘，我也收藏
Flex+J2EE 之小记
Jack. Wang 2008-9-10（本待完善...）
wbjeasygo@163.com
由于本人也是初学者（刚看了两天视频），所以请高手指点，这里赞下 blog 名叫交口称赞的兄弟，他在flex 方面是行家，谢谢了。
摘要：最近晚上抽出点时间写了这篇文章，关于 Flex 开发方面的语言和架构，介绍了大家都熟悉的分层结构，着重介绍视图层（flex 实现），服务控制层和领域模型层，并按照严格分层，高解耦合性并结合 Flex 技术实验了一个用户管理小模块，案例不是目的，重要的是介绍开发思想。本文第一部分介绍 Flex 相关技术以及 ActionStript3.0 语言。第二部分介绍开发实例的开发过程，代码可以下载，亮点在接口工程。由于本人 flex 经验不足，在以后的工作中会不断补充。
关键字：Flex, J2EE, 架构
1. Flex 介绍
FLEX，是Rich Internet Applications时代的牛×产物Rich Internet Applications，翻译成中文为富因特网应用程序。传统网络程序的开发是基于页面的、服务器端数据传递的模式，把网络程序的表示层建立于HTML页面之上，而HTML是适合于文本的，传统的基于页面的系统已经渐渐不能满足网络浏览者的更高的、全方位的体验要求了，这就是被Macromedia公司称之为的“体验问题”，而富因特网应用程序的出现也就是为了解决这个问题。
Flex最重要的两个技术要数AS和MXML, MXML 和 HTML 一样是标记语言，它描述了反映内容与功能的用户界面。与 HTML 不同的是，MXML 可对表示层逻辑与用户界面和服务器端数据绑定提供声明抽象。MXML 可将表示与业务逻辑的问题彻底分开，以实现最大程度地提高开发人员的生产率及应用程序的重复使用率。MXML 的开发基础是在迭代过程上，这与其他类型的 Web 应用程序文件如 HTML、JSP、ASP是相同的。开发 MXML 应用程序就象打开一个文件编辑器一样简单，只要输入一些标签、保存文件，然后在 Web 浏览器上打开文件 URL 即可。
MXML 文件同时也是普通的 XML 文件，所以可以选择多种开发环境。可以在简单文件编辑器、专用 XML 编辑器或是支持文件编辑的集成开发环境 (IDE) 中进行开发。由于 MXML 符合 W3C XML 方案的定义，您也可以使用结构化编辑，如代码着色和代码提示。 MXML和HTML间最大区别：前者定义的应用是编译的SWF文件，执行于FlashPlayer客户端中。后者是基于页面技术的应用。因此前者能提供更丰富的、动态的UI。MXML不支持Flash的某些特性，例如：时间轴。但是可以利用Flash设计组件并应用在Flex中。MXML应用可以是一个MXML文件，也可以是多个MXML组成，MXML支持MXML文件形式的自定义组件、ActionScript文件形式的自定义组件以及在Flash中建立的自定义组件。 FLEX试图通过提供一个程序员们已经熟知的工作流和编程模型，让程序员比从前更快更简单地开发动画及RIA应用。在多层式开发模型中，FLEX应用属于表现层。FLEX的语言和文件结构也试图把应用程序的逻辑从设计中分离出来
总之，flex 是未来界面开发的一个好方向，据我了解很多公司都要求员工要学习 flex 技术，可见 flex 受欢迎的程度。
2 .ActionStript3.0 特性介绍
ActionScript 是针对 Adobe Flash Player 运行时环境的编程语言，它在 Flash 内容和应用程序中实现了交互性、数据处理以及其它许多功能，ActionScript 是由 Flash Player 中的 ActionScript 虚拟机 (AVM) 来执行的。ActionScript代码通常被编译器编译成“字节码格式” ,有点类似 java 的处理和运行机制。变过 C#,Java和javascript程序的朋友，肯定能在 ActionScript 中找到这些语言的影子。
2.1内置命名空间和自定义命名空间
四个内置修饰符：
1 public :对所有代码可见
2 private: 只对类内部可见
3 internal :只对定义所在的同一包内可见
4 protected :对同一包以及不同包的子类可见
自定义命名空间：
使用关键字namespace定义命名空间，声明属性和方法时，应用命名空间。
AS 代 码：
1
2Namespace testSpace="org.blogjava.jm/testSpace ";
3testSpace myfunction2():void{}
4
5use mySpace2;
6myfunction2(); //调用使用 use 关键字打开命名空间
2.2 Local 变量特点
与java不同的是，在as3中，变量没有块级作用域（即两人大括号中间），如果在一个块内声明了一个变量，比如一个for循环内声明了一个变量，它在该代码所在整个函数内都是可访问的
1function myFunction():void{
2 for(var i:int=0;i<5:i++){
3 var last:int = i;
4 }
5 trace(last); //last 在 for 中定义但可以在 for 块外面访问到，个人觉得这样设计欠妥，尽管很方便。
6} 2.3 Dynamic 类
Object 类本身就是动态类，当然也可以用 dynamic 关键字来声明一个类，所谓动态就是在运行时可以对类追加属性和方法。
1dynamic class Protean{}
2var myProtean:Protean = new Protean();
3myProtean.name = "jack.wang";
4myProtean.password = 3;
5trace(myProtean. name , myProtean.password );
2.4 定义函数的两种方式：函数语句和函数表达式
1//函数语句声明
2Function fun1():void{}
3
4//函数表达式声明
5var fun2:Function = function():void{}
6//函数表达式声明的函数是不能够被垃圾回收的，必须显示的调用 delete 命令。
7var t:Test = new Test(); //t是动态类Test的一个实例
8t.funt = function(){};//把一个函数声明为t的一个属性
9delete t.funt; //删除刚才新增的函数，我们刚才声明的函数也被回收了
10
2.5 在as3中也有arguments对象，功能基本上和javascript中的一样。
arguments 对象是一个数组，其中包括传递给函数的所有参数，arguments.length 属性报告传递给函数的参数数量，（避免将 "arguments" 字符串作为参数名，因为它将遮蔽 arguments 对象）
function traceArgArray(x:int):void
{
for (var i:uint = 0; i < arguments.length; i++) {
trace(arguments[i]);
}
}
traceArgArray(1, 2, 3);
// 输出：
// 1
// 2
// 3
当然也可以用类似 java 的形式 function traceArgArray(x: int, args)
2.6 在as3中允许定义同名的静态属性和实例属性
1class StaticTest {
2 static var message:String = "static variable";
3 var message:String = "instance variable"; }
4 var myST:StaticTest = new StaticTest();
5trace(StaticTest.message); // 输出：静态变量 trace(myST.message); // 输出：实例变量
2.7 在as中有一个叫做set和get存取器的东西，类似JavaBean，但又有所不同。
class GetSet {
private var privateProperty:String;
public function get publicAccess():String{
return privateProperty;
}
public function set publicAccess(setValue:String):void { privateProperty = setValue;
}
}
3 个人实验介绍
案例是超级简单的，开发Web 应用的，不管你是基于 J2EE,.net 平台还是其他的 PHP 等等都很熟悉分层架构，其中五层是最熟悉不过的了，一般分为表示层，控制层，服务层，模型层和数据层，有的公司干脆就把服务层和模型层合并起来和控制层合并在一起，基于分层的开发可以横向也可以纵向，由于引入 flex 技术，因为并不是所有人都懂得 flex 开发方式，尽管他和传统的 Swing, SWT，GWT开发很相近 ，不过这样需求分析时可以构建可演进的原型系统，界面也很 RIA。
人们常提面向接口编程于是经常看到 IUser user=new User();这样的代码，似乎就是在用接口，但是 new 的动作还是有依赖，于是人们用一些设计模式比如 Factory, Proxy，反射等等模式，后来又有了更好的依赖注入，似乎很完美了，可人们又陷进了过度设计，其实接口应用比直接用原类要多耗费几个机械指令 User user=new User()，而且在一个内聚的组件中尽量用对象直接连接，该分开的时候我们去用接口分，接口的目的是为了抽象，抽象的目的是为了解耦。
本开发为了把模型层和服务层完全分开，引入接口工程，也就是单独开发一个工程来设计接口，这个工程有设计师开发。 用户接口和工厂接口这两个类在单独的工程里开发，以便于模型和服务层同步开发。 在服务层不能对外暴露 IUser 接口，而他也要接受数据，这里用的是 UserVO 对象来封装数据，服务层不操作模型层的任何实现类，这样这两层之间完全解耦,当接口工程和实现完成时候打成 jar 包到 web 工程下 Flex 开发和 HTML开发有很大的不同，客户端和服务端交互的不是 HTML 而是 XML，所以在服务器端 的 Servlet 就应该输出 XML 流到客户端。 最后 Flex 也是一个单独的工程，通过 HTTPService 和 Web 服务器端交互数据。
下载：我的实验代码
其他视频资料：http://www.blogjava.net/Jack2007/archive/2008/09/05/227125.html
参考文献
1.http://ezen.javaeye.com/blog/107397
2.http://www.nshen.net/blog/article.asp?id=555
3. http://blog.csdn.net/mozilla/archive/2007/08/23/1756761.aspx
4.http://hi.baidu.com/jlhh/blog/item/225aea197716b77adab4bd7f.html
5.http://yexin218.javaeye.com/blog/203032
6.http://yexin218.javaeye.com/blog/203032
7.http://www.blogjava.net/realsmy/archive/2008/01/17/176054.html
8. http://daoger.javaeye.com/blog/204694
9. http://www.blogjava.net/alps/archive/2008/07/23/216940.html
10.http://xy-z487.javaeye.com/blog/238074
11.http://www.pin5i.com/showtopic-19682.html
12. http://goday.blogbus.com/logs/13402716.html
13. http://www.flashas.net/html/Flex/20070525/1779.html
14. http://www.bluejia.cn/blog/?action=show&id=18
MSN: wbjeasygo@163.com
Email: wbjeasygo@163.com
QQ 群：47763528 69908706
个人空间
http://www.blogjava.net/Jack2007/archive/2008/09/11/228212.html
villa123收录，使用标签：Java，时间：2008-9-12 18:07:49 | 相关网摘，我也收藏
先让大家看看效果图吧：
还不错吧，只是有点遗憾的是标题栏没有改变！如果标题栏也改变了，那就完美了！如果谁有更好的方法不妨留言交流一下！共同学习！
具体的方法是：启动NetBeans 的时候添加启动参数
netbeans -cp:p D:/NBpro/quaqua.jar --laf ch.randelshofer.quaqua.QuaquaLookAndFeel
红色部分表示的是你的laf jar包所在文件夹。quaqua jar包 点击这里下载
用这种方法还可以设置其它的外观，不仅如此，这样还修正了NetBeans在Windows 默认的主题下显示的问题（第一张图片红色框框部分）
具体内容你们也可以看看这篇博客：http://mrhaki.blogspot.com/2008/09/using-jtattoo-look-and-feel-with.html
http://www.blogjava.net/gml520/archive/2008/09/10/228245.html
villa123收录，使用标签：Java，时间：2008-9-12 17:52:30 | 相关网摘，我也收藏
Spring+ibatis+Oscache缓存管理精要
本文主要讲解在框架中的缓存管理，略去一些搭建框架过程，假定框架已建好。
在实际的开发运营过程中，有时需要对缓存进行手工刷新，下面从以下几点讲解：
1.JSP层，代码如下：
<%@ taglib uri="/WEB-INF/classes/oscache.tld" prefix="os"%>
缓存内容
说明：此处用到group属性，为的是对缓存归类，以便后续手工刷新某组缓存
在另一个jsp管理页刷新此组缓存：
2.对ibatis中的sql数据缓存刷新
先从Spring的工厂中获得实例，建立辅助类SpringContextUtil.java
package com.yown.util;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext; //Spring应用上下文环境
/**
* 实现ApplicationContextAware接口的回调方法，设置上下文环境
* @param applicationContext
* @throws BeansException
*/
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtil.applicationContext = applicationContext;
}
/**
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 获取对象
* @param name
* @return Object 一个以所给名字注册的bean的实例
* @throws BeansException
*/
public static Object getBean(String name) throws BeansException {
return applicationContext.getBean(name);
}
/**
* 获取类型为requiredType的对象
* 如果bean不能被类型转换，相应的异常将会被抛出（BeanNotOfRequiredTypeException）
* @param name bean注册名
* @param requiredType 返回对象类型
* @return Object 返回requiredType类型对象
* @throws BeansException
*/
public static Object getBean(String name, Class requiredType) throws BeansException {
return applicationContext.getBean(name, requiredType);
}
/**
* 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
* @param name
* @return boolean
*/
public static boolean containsBean(String name) {
return applicationContext.containsBean(name);
}
/**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
* 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
* @param name
* @return boolean
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*/
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
return applicationContext.isSingleton(name);
}
/**
* @param name
* @return Class 注册对象的类型
* @throws NoSuchBeanDefinitionException
*/
public static Class getType(String name) throws NoSuchBeanDefinitionException {
return applicationContext.getType(name);
}
/**
* 如果给定的bean名字在bean定义中有别名，则返回这些别名
* @param name
* @return
* @throws NoSuchBeanDefinitionException
*/
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
return applicationContext.getAliases(name);
}
}
然后在applicationContext.xml声明实例SpringContextUtil，配置如下：
...
经过以上配置，就可以方便对sql中指定缓存进行刷新了，如下是sql.xml：
select id,title from news
刷新指定缓存代码：
SqlMapClient sqlMapClient=(SqlMapClient)SpringContextUtil.getBean("sqlMapClient");
sqlMapClient.flushDataCache("News.fastNewsCache");
就是这样，呵呵！
http://blog.csdn.net/yown/archive/2008/09/12/2917337.aspx
villa123收录，使用标签：Java，时间：2008-9-12 15:38:12 | 相关网摘，我也收藏
我们记得在前一篇《魔幻数组》系列中的例子中使用了一个名为list6的数组，如下：
def list6 = [ 1, 1, 2, 2, 3, 3, 3, 5 ]
看到了它，我们就可以看到里面有很多重复元素，我们马上也就有了要把重复元素去掉的要求。
在Java语言中，我们也有去掉List对象中重复元素的简单方法，那就是使用Set对象，因为Set对象是没有重复元素的。如下：
List list = new ArrayList();
list.add("a");
list.add("a");
list.add("b");
在Java语言中，初始化一个List对象的确是一件烦心的工作，别理它，我们接着往下做：
Set set = new HashSet();
set.addAll(list);
可以看到，我们把list对象的元素放到了set对象里，感谢“addAll”方法，让我们的工作减轻了很多。下面就是将set对象的元素“addAll”回List对象了：
List list1 = new ArrayList();
list1.addAll(set);
也很简单，下面我们来看看list1对象的元素到底咋样了：
for(int i=0;i
{
System.out.println(list1.get(i));
}
结果为：
a
b
可以看到，list对象中的重复的“a”元素的确没有了，达到了我们的目的。在Java语言中，去掉List对象中的重复元素比较简单，就是将元素“allAll”进Set对象，然后再将元素“allAll”回List对象。
但是，在Groovy语言中，我们的方法更加简单，不需要用到Set对象，而是使用“unique”方法。如下：
def list5 = [ 1, 1, 2, 2, 3, 3, 3, 5 ].unique()
println list5
结果为：
[1, 2, 3, 5]
可以看到，在Groovy语言中使用“unique”方法的确比Java语言达到相同的目的要简单得多。但是“unique”方法还有更广泛的用途，比如我们如下的一个GroovyBean对象：
class Empl
{
String id;
String name;
}
同时，我们有了如下的一个以Empl对象为元素的数组：
def list9 = [new Empl(id:1,name:'a'),new Empl(id:2,name:'b'),new Empl(id:1,name:'c')]
可以看到，list9对象有三个元素，其中第一个元素和第三个元素的“id”属性的值是相同的。如果我们有如下要求：我们对于Empl的对象如果id属性的值相同的话，就视为同一个对象；如果list9对象中有相同的Empl对象，那么我们要去掉相同的元素。对于这样的要求，我们在Java语言中使用Set对象是无法实现的。但我们在Groovy语言中却能够使用“unique”方法实现。请看下面的代码：
def list10 = list9.unique{
it.id
}
可以看到，对于上一个“unique”方法没有输入参数，但这里的“unique”方法却有一个闭包对象作为输入方法，这个闭包对象告诉“unique”方法使用什么方法来辨别数组中的元素相同。如上例中是使用数组中元素的“id”属性是否相等来区别数组中的元素是否相同的。
我们来看一下上例中的结果：
list10.each{
println "${it.id} : ${it.name}"
}
结果为：
1 : a
2 : b
可以看到，list10对象中的确只剩下两个元素了。
在Groovy语言中，“unique”方法不但比Java语言达到相同的目的要简单得多，而能对数组元素为GroovyBean对象的数组也能去掉重复元素，从而使得使用范围更加广泛。
http://blog.csdn.net/hivon/archive/2008/09/10/2907019.aspx
villa123收录，使用标签：Java，时间：2008-9-12 10:51:14 | 相关网摘，我也收藏
在Java SE6中为我们提供了标准的包来操作Java编译器。Java SE 6 做为一个开发平台，针对不同的应用开发需求，提供了各种各样的技术框架。XML 处理框架是 JDK 6 的重要组成部分之一。它为应用程序开发人员提供了一个统一的 XML 处理 API。
热点：
*b31的变化 。最新的补丁列表已经推出，可用。
*6u10的新特性，请参阅测试向导。
*如果您发现任何与6u10有关的错误，请提交他们： http://bugreport.sun.com 。
http://news.csdn.net/n/20080912/118988.html
共617个网摘 [
1 2 3 4 5 6 ...
21 ]
下一页