JavaEye博客

Java Web 组件开发中OSGi与JSP、JSTL标签库的联姻

danlley — Fri, 25 Jul 2008 18:54:56 +0800

作者: danlley 链接：http://danlley.javaeye.com/blog/219622 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

在前一篇文章中，通过OSGi（Open Services Gateway Initiative）的热插拔特性，我们已经窥见了OSGi在Java Web开发中的一些优势。但是因为OSGi是最早为嵌入式系统设计，所以OSGi标准中的HTTP服务只提供了有限的Servlet与静态资源的发布功能，没有一个完整的WEB容器概念，这种模式更适合通过WEB方式暴露(Export)服务，不太适合开发展现层的WEB应用。这也是导致很多公司很少涉足这个领域的很大因素。在这份文档中，用一个简单的例子来说明如何在使用JSP以及使用JSTL等标签库的情况下应用OSGi开发基于组建的Web应用。

1. 创建plug-in工程osgi_jsp_test

2. 在工程的根目录下创建"web"目录，并在其中增加WEB-INF文件夹。

3. 建立web.xml文件，内容如下：



    JSP 2.0 Examples.
    JSP 2.0 Examples

4.编写JSP，内容如下
foreach.jsp



Tag Plugin Examples: forEach




    Tag Plugin Examples - 
    


    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    <%@ page import="java.util.Vector" %>
    Iterating over a range
    
	${item}     
    
    <%
	Vector v = new Vector();
	v.add("One");
	v.add("Two");
	v.add("Three");
	v.add("Four");
	pageContext.setAttribute("vector", v);
    %>
    Iterating over a Vector
    
	${item}     
    



    Tag Plugin Examples - 

    
    

    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    Set the test result to a variable
    
    The result of testing for (1==1) is: ${theTruth}
    Conditionally execute the body
    
	It's true that (2>0)!
    



    Tag Plugin Examples - 
    


    

    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    # ${index}:
	
	    One!

	    Four!

	    Three!

	    Danlley?

5. 编辑配置文件

---------------------------------------------------
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Osgi_jsp_test Plug-in
Bundle-SymbolicName: osgi_jsp_test
Bundle-Version: 1.0.0
Bundle-ClassPath: target/classes/,
lib/jstl.jar,
lib/standard.jar
Bundle-Activator: org.danlley.osgi.jsp.common.Activator
Import-Package: org.osgi.framework;version="1.3.0"
Require-Bundle: javax.servlet,
javax.servlet.jsp,
org.mortbay.jetty,
org.apache.commons.logging,
org.apache.commons.el,
org.apache.jasper,
org.eclipse.equinox.http.registry,
org.eclipse.equinox.http.helper,
org.eclipse.equinox.http.jetty,
org.eclipse.equinox.http.servlet,
org.eclipse.equinox.jsp.jasper,
org.eclipse.equinox.jsp.jasper.registry,
org.eclipse.equinox.registry,
org.eclipse.equinox.common,
org.eclipse.equinox.app,
org.eclipse.osgi,
org.eclipse.osgi.util,
org.eclipse.osgi.services,
org.eclipse.core.commands,
org.eclipse.core.jobs
---------------------------------------------------

6. 修改Activator类
注，由于Bundle可以在任何时候安装，启动，停止或卸载，所以使用其他Bundle提供的服务时，必须跟踪这些服务的状态。如果在一个Bundle中需要使用其他Bundle提供的服务，则需要在考虑服务不存在或突然被注销的情形。由于OSGi环境是一个动态的环境，如果使用一个服务，可以使用ServiceTracker对该服务进行跟踪。我们在这里使用一下ServiceTracker，在OSGi提供的接口中，对ServiceTracker提供了四种对象初始化方式：

import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTrackerCustomizer;
import org.osgi.framework.Filter;

public ServiceTracker(BundleContext context,ServiceReference reference,ServiceTrackerCustomizer 
customizer);

public ServiceTracker(BundleContext context,String clazz,ServiceTrackerCustomizer customizer);

public ServiceTracker(BundleContext context,Filter filter,ServiceTrackerCustomizer customizer);

BundleContext是一个OSGi框架与Bundle之间进行交互的一个结合点。当代码需要在任何时候与框架交互时，你将用到BundleContext。事实上这是用OSGi API交互的唯一方法，并且在框架启动Bundle的时候时，每个Bundle的Activator都会接收到BundleContext的实例。

OSGi中services总是通过ServiceReference来访问的，他唯一对应一个service对象要访问的一个服务，以下步骤是必须的：
1)。获取ServiceReference引用
2)。通过BundleContext.getService()获取服务对象实例

final HttpService httpService = (HttpService) context.getService(reference);

ServiceTrackCustomer是由OSGi提供的一个用于监控服务的接口类，当在OSGi里面注册,修改,反注册一个Service的时候，OSGi会调用ServiceTrackCustomer的方法addingService, modifiedService, removedService. 关于这个方面的示例，我想应该可以在我的另外一篇文章《管窥Java开发中OSGi组件的热插拔》中找到：http://danlley.javaeye.com/blog/218676

接下来，实现Activator类，由于我们需要执行JSP页面，因此就需要在系统中加载JspServlet，为此，我们需要复写在类中实现的一个成员方法：

public java.lang.Object addingService(org.osgi.framework.ServiceReference reference);

实现如下：

public Object addingService(ServiceReference reference) {
	final HttpService httpService = (HttpService) context.getService(reference);
	try {
		System.out.println("开始注册JspServlet");
		HttpContext commonContext = new BundleEntryHttpContext(context.getBundle(), 
		"/web"); 
		httpService.registerResources("/jsp-examples", "/", commonContext);
		Servlet adaptedJspServlet = new ContextPathServletAdaptor(new 
		JspServlet(context.getBundle(), "/web"), "/jsp-examples"); 
		httpService.registerServlet("/jsp-examples/*.jsp", adaptedJspServlet, null, 
		commonContext); 
		System.out.println("JspServlet注册结束");
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return httpService;
}

HttpService 通过这样的方法来注册资源文件：HttpService.registerResources(资源 Mapping Url,资源文件路径, HttpContext 实例);

示例：service.registerResources("/demo/page","page",null);

构建HttpContext实例，org.eclipse.equinox.http.helper项目为我们已经做好了一个构建HttpContext实例的类，并提供了两个构造方法：

public BundleEntryHttpContext(Bundle bundle);
public BundleEntryHttpContext(Bundle b, String bundlePath);

HttpContext接口的定义如下：

public abstract interface org.osgi.service.http.HttpContext {
	public static final java.lang.String REMOTE_USER = "org.osgi.service.http.authentication.remote.user";
	public static final java.lang.String AUTHENTICATION_TYPE = "org.osgi.service.http.authentication.type";
	public static final java.lang.String AUTHORIZATION = "org.osgi.service.useradmin.authorization";
	public boolean handleSecurity(javax.servlet.http.HttpServletRequest arg0, 
	javax.servlet.http.HttpServletResponse arg1)throws java.io.IOException;
	public java.net.URL getResource(java.lang.String arg0);
	public java.lang.String getMimeType(java.lang.String arg0);
}

在BundleEntryHttpContext对HttpContext接口的实现过程时，如果我们采用的是第二种方式（传入BundlePath），在调用getResource()方法时，resourceName就会加上BundlePath作为路径前缀。

适配器ContextPathServletAdaptor事实上是对javax.servlet.Servlet接口的一个实现。Servlet接口定义如下：

public abstract interface javax.servlet.Servlet {
	public abstract void init(javax.servlet.ServletConfig arg0) throws 
		javax.servlet.ServletException;
	public abstract javax.servlet.ServletConfig getServletConfig();
	public abstract void service(javax.servlet.ServletRequest arg0, 
		javax.servlet.ServletResponse arg1) throws 
		javax.servlet.ServletException, java.io.IOException;
	public abstract java.lang.String getServletInfo();
	public abstract void destroy();
}

Eclipse的org.eclipse.equinox.http.servlet项目对OSGi的HttpService做了一个实现类HttpServiceImpl，通过他提供的registerServlet接口实现，我们就可以将JspServlet注册到我们的OSGi环境中。HttpServiceImpl的接口实现声明如下

public class org.eclipse.equinox.http.servlet.internal.HttpServiceImpl implements org.osgi.service.http.HttpService {
	private org.osgi.framework.Bundle bundle;
	private org.eclipse.equinox.http.servlet.internal.ProxyServlet proxy;
	java.util.Set aliases;

	public HttpServiceImpl(org.osgi.framework.Bundle bundle, 
		org.eclipse.equinox.http.servlet.internal.ProxyServlet proxy);
	public synchronized void unregisterAliases();
	public synchronized void registerServlet(java.lang.String alias, javax.servlet.Servlet servlet, 
		java.util.Dictionary initparams, org.osgi.service.http.HttpContext context) throws 
		javax.servlet.ServletException, org.osgi.service.http.NamespaceException;
	public synchronized void registerResources(java.lang.String alias, java.lang.String name, 
		org.osgi.service.http.HttpContext context) throws org.osgi.service.http.NamespaceException;
	public synchronized void unregister(java.lang.String alias);
	public org.osgi.service.http.HttpContext createDefaultHttpContext();
}

下面给出Activator类代码的完整实现，代码如下：

Activator.java

package org.danlley.osgi.jsp.common;


import javax.servlet.Servlet;

import org.eclipse.equinox.http.helper.BundleEntryHttpContext;
import org.eclipse.equinox.http.helper.ContextPathServletAdaptor;
import org.eclipse.equinox.jsp.jasper.JspServlet;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.service.http.HttpContext;
import org.osgi.service.http.HttpService;
import org.osgi.util.tracker.ServiceTracker;

public class Activator implements BundleActivator {

	private ServiceTracker httpServiceTracker;

	public void start(BundleContext context) throws Exception {
		httpServiceTracker = new HttpServiceTracker(context);
		httpServiceTracker.open();
	}

	public void stop(BundleContext context) throws Exception {
		httpServiceTracker.open();
	}

	private class HttpServiceTracker extends ServiceTracker {

		public HttpServiceTracker(BundleContext context) {
			super(context, HttpService.class.getName(), null);
		}

		public Object addingService(ServiceReference reference) {
			final HttpService httpService = (HttpService) context.getService(reference);
			try {
				System.out.println("开始注册JspServlet");
				HttpContext commonContext = new BundleEntryHttpContext(context.getBundle(), 
				"/web"); 
				httpService.registerResources("/jsp-examples", "/", commonContext);
				Servlet adaptedJspServlet = new ContextPathServletAdaptor(new 
				JspServlet(context.getBundle(), "/web"), "/jsp-examples"); 
				httpService.registerServlet("/jsp-examples/*.jsp", adaptedJspServlet, null, 
				commonContext); 
				System.out.println("JspServlet注册结束");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return httpService;
		}

		public void removedService(ServiceReference reference, Object service) {
			final HttpService httpService = (HttpService) service;
			httpService.unregister("/jsp-examples"); 
			httpService.unregister("/jsp-examples/*.jsp"); 
			super.removedService(reference, service);
		}
	}
}

7.启动服务
----------------------------------------------------------------------------
osgi> Jul 25, 2008 4:51:00 PM org.mortbay.http.HttpServer doStart
INFO: Version Jetty/5.1.x
Jul 25, 2008 4:51:00 PM org.mortbay.util.Container start
INFO: Started org.mortbay.jetty.servlet.ServletHandler@10f6d3
Jul 25, 2008 4:51:00 PM org.mortbay.util.Container start
INFO: Started HttpContext[/,/]
Jul 25, 2008 4:51:00 PM org.mortbay.http.SocketListener start
INFO: Started SocketListener on 0.0.0.0:80
Jul 25, 2008 4:51:00 PM org.mortbay.util.Container start
INFO: Started org.mortbay.http.HttpServer@1adc30
开始注册JspServlet
JspServlet注册结束
ss

Framework is launched.

id State       Bundle
0 ACTIVE      org.eclipse.osgi_3.3.2.R33x_v20080105
1 ACTIVE      javax.servlet_2.4.0.v200706111738
3 ACTIVE      org.eclipse.equinox.jsp.jasper.registry_1.0.0.v20070607
4 ACTIVE      org.eclipse.core.jobs_3.3.1.R33x_v20070709
5 ACTIVE      javax.servlet.jsp_2.0.0.v200706191603
6 ACTIVE      org.apache.commons.logging_1.0.4
7 ACTIVE      org.apache.commons.logging_1.0.4.v200706111724
8 ACTIVE      org.eclipse.equinox.http.helper_1.0.0.qualifier
9 ACTIVE      org.eclipse.osgi.services_3.1.200.v20070605
10 ACTIVE      org.eclipse.equinox.jsp.jasper_1.0.100.qualifier
11 ACTIVE      org.eclipse.core.commands_3.3.0.I20070605-0010
12 ACTIVE      org.eclipse.equinox.http.registry_1.0.1.R33x_v20071231
13 ACTIVE      org.apache.commons.el_1.0.0.v200706111724
14 ACTIVE      org.eclipse.equinox.common_3.3.0.v20070426
15 ACTIVE      org.eclipse.equinox.http.jetty_1.0.1.R33x_v20070816
16 ACTIVE      org.eclipse.equinox.app_1.0.1.R33x_v20070828
17 ACTIVE      org.mortbay.jetty_5.1.11.v200706111724
18 ACTIVE      org.eclipse.equinox.http.servlet_1.0.1.R33x_v20070816
19 ACTIVE      org.eclipse.equinox.registry_3.3.1.R33x_v20070802
21 ACTIVE      org.apache.jasper_5.5.17.v200806031609
24 ACTIVE      org.eclipse.osgi.util_3.1.200.v20070605
32 ACTIVE      osgi_jsp_test_1.0.0
----------------------------------------------------------------------------

8.访问页面
地址：http://localhost/jsp-examples/foreach.jsp

结束！

参考资料：
http://switchlau.javaeye.com/blog/219276
http://dev2dev.bea.com.cn/blog/chrisrc/200712/28_807.html
http://jncz.javaeye.com/blog/173902
http://www.iocblog.net/project/equinox/equinox-544.html
http://www.diigo.com/user/samlet?domain=www.ibm.com

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

java中匿名内部类的两种实现方式

ayis — Fri, 25 Jul 2008 17:11:46 +0800

作者: ayis 链接：http://ayis.javaeye.com/blog/219590 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

使用匿名内部类课使代码更加简洁、紧凑，模块化程度更高。内部类能够访问外部内的一切成员变量和方法，包括私有的，而实现接口或继承类做不到。然而这个不是我说的重点，我说的很简单，就是匿名内部类的两种实现方式：第一种，继承一个类，重写其方法；第二种，实现一个接口（可以是多个），实现其方法。下面通过代码来说明：

public class TestAnonymousInterClass{
	public static void main(String args[]){
		TestAnonymousInterClass test=new TestAnonymousInterClass();
		test.show();
	}
	//在这个方法中构造了一个匿名内部类
	private void show(){
		Out anonyInter=new Out(){// 获取匿名内部类实例
			
			void show(){//重写父类的方法
				System.out.println("this is Anonymous InterClass showing.");
			}
		};
		anonyInter.show();// 调用其方法
	}
} 

// 这是一个已经存在的类，匿名内部类通过重写其方法，将会获得另外的实现
class Out{
	void show(){
		System.out.println("this is Out showing.");
	}
}

程序运行的输出结果为：

this is Anonymous InterClass showing.

所以在这里看出，匿名内部类有了自己的实现。其实很简单，使用匿名内部类是因为我这地方需要有点什么特殊的实现，所以我就在这地方把具体实现也给了出来了。然后我就在这地方获取它的实例，调用它的方法。

接口的方式，只要把父类换成接口就行了，没必要给出代码了。

使用匿名内部类时我们不要忘了我们的目的，我们只是在这地方想对某个类有特殊的实现。而不要想得太多，在匿名内部编写其它的方法。在匿名内部类中编写的自己的方法是不可见的。此种做法是毫无意义的，当然一般也不会这么做。在这里只是告诉初学者对于匿名内部类不要想的太多，而要这么想：匿名内部类就是重写父类或接口的方法。

匿名内部类是没有名字的，所以我们没办法获得其类型，而只能把它当作超类或接口类型来使用。

当然，我这篇文章不是很有深度。欢迎发表意见!

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

与妻生日书

lcllcl987 — Fri, 25 Jul 2008 15:29:50 +0800

作者: lcllcl987 链接：http://lcllcl987.javaeye.com/blog/219552 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

昨天是欣的生日, 特在我的技术blog开个先河, 贴一篇我的与技术无关的文字, 博大家一笑耳!

    余妻冯氏, 壬戌生, 体态婀娜, 肤如凝脂, 有腰盈盈一握, 盖余心中之美人矣.
    妻乃邻郡黄冈人,闻先生同乡.此郡素为诗山文海之地, 且先生诗文冠绝海内, 然妻竟无斯文之万一. 每与典故论之,常做茫然无辜状. 且性刚烈,余常讥其决决乎如厕之顽石, 且臭且硬. 妻每每驳而自诩小燕子耳.
    妻贤良, 但常有惊人之举, 在此表其一也. 本名细枝, 乡土甚浓, 自度恐他人笑, 遂改名, 单字欣, 且迫众人从之.然衙役之证未改, 余谓曰不妥, 答曰: 无它, 但求悦耳矣. 遂晕厥.
    妻善持家务, 但凡周末, 必扫全屋, 不遗一瓶一钵. 四载间, 余未曾洗一袜, 扫一地耳. 且节俭甚, 宛若余母. 每每告之不必如此.
    妻则正色曰: 妾既嫁君, 当改君夙之奢习, 集细流以成大海, 由小康而富足. 恩爱简朴, 虽千户侯不足贵. 余心慰之.

    昨日妻生日, 余未有一语贺之. 及归, 妻自下寿面,曰:君心无妾矣! 凄凄然有泪盈眶.
    余深自责. 适逢停电, 遂寻一烛, 燃于妻前, 曰: 卿卿错焉. 今日忙于公案, 但时时念汝之生日不可忘. 无暇购礼, 借红烛以谢君耳!祝卿卿生日快乐, 许愿以吹之. 妻破涕为笑, 默许一愿, 吹之. 余问之, 答曰:愿一生平安, 与君白首.

    今作此文表余心, 勉作生日之礼, 稍慰矣.

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

监听器ServletContextListener小记

scnujie — Fri, 25 Jul 2008 15:04:22 +0800

作者: scnujie 链接：http://scnujie.javaeye.com/blog/219535 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天奉命写一个监听器监听tomcat，在tomcat启动后隔半个小时生成一些要求的静态页面，因为没写过监听器，所以在网上看了一些资料后觉得不是很难就很兴奋地开始动手，
用了ServletContextListener,可没想到监听是监听到了，但是搞得tomcat启动的时候一路在监听，以为是这个监听器不适合就换成了session的，以为快成功的
时候老大又说不行（后来一想也确实不行），所以又换回ServletContextListener来继续搞，后来上网看来看去原来用这个监听器才是符合要求的，一开始那种
只不过是因为我把定时器Timer定义在了ServletContextListener的初始化函数里面了，搞得tomcat启动时老是在监听而启动不了，后来我把定时器Timer定义在
另外一个类里面，再在ServletContextListener的初始化函数里面调用就搞定了。还是没经验啊。

不过这里还有个问题：如何在这个初始化函数里面获得tomcat的IP和端口呢？也许很难，也许很easy,还不知道！

Listener:

public class GenPagesListener implements ServletContextListener
{
        private DoSomething ds = null;
        
    public void contextInitialized(ServletContextEvent sce) {
            
            String rootPath = new File(sce.getServletContext().getRealPath("/")).getParentFile().toString();
                if(rootPath.contains("\\"))
                {
                        rootPath = rootPath.replace("\\", "/")+"/ROOT";
                }
                String hostPath = AppPropertyUtil.getProperty("webUrl");
                
                
                GlobeContext.setRootPath(rootPath);
                GlobeContext.setHostPath(hostPath);
            
            ds = new DoSomething(1000,1800000);
    }

    public void contextDestroyed(ServletContextEvent sce) {
       ds.destoryTimer();
    }


}

中间类：

 public class DoSomething {

        private java.util.Timer timer;
        public DoSomething(int a,int b)
        {
                timer = new Timer();
                timer.schedule(new GenPageTask(), a,b);
        }
        
        public void destoryTimer(){
            timer.cancel();
            }
}

要执行的任务：

public class GenPageTask extends TimerTask{
        
        public void run()
        {
                ApplicationContext context = GlobeContext.getApplicationContext();
                IChannelManager channelManager = (IChannelManager)context.getBean("channelManager");
                List list = channelManager.getObjectList(Restrictions.eq("type", 1));        
                                
                for(Channel ch : list)
                {
                        Long lid = ch.getId();
                        try{
                        publishChannel(lid);
                        }
                        catch(Exception e)
                        {
                           e.printStackTrace();        
                        }
                }
        }
        
        public void publishChannel(Long lid) throws Exception
        {

                String root = GlobeContext.getRootPath();
                String rootpath = GlobeContext.getHostPath();
                ApplicationContext context = GlobeContext.getApplicationContext();
                IChannelManager channelManager = (IChannelManager)context.getBean("channelManager");
                ChannelView chan = channelManager.getView(lid);
                String puppath = root + chan.getFullPath();
                File file = new File(puppath);
                if (!file.exists()) {
                        file.mkdirs();
                }

                int pageSize = Integer.valueOf(AppPropertyUtil
                                .getProperty("listPageSize"));
                if (chan.getPageSize() != null) {
                        pageSize = chan.getPageSize();
                }
                try {
                        List cris = new ArrayList();
                        cris.add(Restrictions.eq("channelId", chan.getId()));
                        cris.add(Restrictions.eq("struts", 1));
                        IDocumentManager documentManager = (IDocumentManager)context.getBean("documentManager");
                        int totalPage = documentManager.getPageObject(0, pageSize, cris)
                                        .getTotalPage();

                        for (int page = 1; page <= totalPage; page++) {
                                String index = "";
                                if (page == 1) {
                                        index = "index";
                                } else {
                                        index = "list_" + page + "";
                                }
                                String url = rootpath
                                                + "admin/channel/docList.htm?data.channelId="
                                                + chan.getId() + "&data.page=" + page;
                                HtmlGenUtil.writeHtml(puppath + index + ".shtml", HtmlGenUtil
                                                .getHtmlCode(url), "YES");
                        }
                } catch (Exception e) {
                        e.printStackTrace();
                }
        }
}

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

[SAP]Bank account, House bank, Bank Account基础

blueoxygen — Fri, 25 Jul 2008 14:50:32 +0800

作者: blueoxygen 链接：http://sap.javaeye.com/blog/219526 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

House Bank: A business partner that represents a bank via which you can process your own internal transactions. 也就是说，你的内部业务处理所需要的一个银行。但是并非是只有一个科目或者一个帐户。
House Bank中的每一个帐户，靠Account ID来区别。House Bank和Account ID组合在一起，就唯一确定了一个Bank Account. 每个Bank Account都指定了一个唯一的G/L中的科目。

他们三个之间的关系如下

在IDES系统中，我们演示如下。

首先在找到一个G/L Account主数据，然后看到有House Bank和Account ID两个栏位。

TCODE：FI12进入到后台配置，我们就可以看到一个House Bank体现了一个Bank Key定义的银行主数据，而一个House Bank下会有很多Account ID， House Bank和Account ID确定了唯一的一个Bank Account，每个Bank Account会制定一个G/L Account。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

jni 中的 signature

fly_hyp — Fri, 25 Jul 2008 14:18:03 +0800

作者: fly_hyp 链接：http://fly-hyp.javaeye.com/blog/219509 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近在研究jni编程。碰到一些问题记录一下。有需要的朋友可以拿去用

jni 有一个函数是

jmethodID (JNICALL *GetStaticMethodID)
      (JNIEnv *env, jclass clazz, const char *name, const char *sig);

其中参数 sig （signature）在文档中说明的不太清楚。

可以通过javap命令获得相应的 methed signature

例如：

javap -classpath myJavaUtils.jar -s com.lang.JavaUtil

javap -s -p Prompt

网上搜了很多，下面这些还不错：

http://journals.ecs.soton.ac.uk/java/tutorial/native1.1/implementing/method.html

http://java.sun.com/javase/6/docs/technotes/guides/jni/spec/design.html#wp133

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Jqury回调

Jatula — Fri, 25 Jul 2008 14:07:40 +0800

作者: Jatula 链接：http://jatula.javaeye.com/blog/219506 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

动作：

function saveDefault(ptid){

var httpRequest;
httpRequest = $.get("<%=request.getContextPath()%>/play/playList.do?do=savePlayTime&id="+ptid+"&startTime="+starttime+"&endTime="+endtime+"","",function(){saveHourOk("stateHour_"+ptid,httpRequest)});}

处理：

httpRequest为回调部分

前面请求部分返回处理为：out.print("success");

不要用out.println()，不然出错；

CallBack:

function saveHourOk(id,httpRequest){
  var message=httpRequest.responseText;
  alert(message);
  alert(id);
  if(message=="true"){
   showMsg(id,"");
   }else{
   showMsg(id,"");
   }
  miss(id);
}

//返回信息
function showMsg(id,msg){
show(id);
var obj = document.getElementById(id);
obj.innerHTML = msg;

miss(id);

}

//消失吧
function miss(id){
window.setTimeout(function(){$("#"+id).fadeOut('slow')},4000);
//window.setTimeout(function(){hide(id)},3000);
}

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

polish学习心得

LinuxFans — Fri, 25 Jul 2008 13:00:37 +0800

作者: LinuxFans 链接：http://kuikui.javaeye.com/blog/219454 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

记得去年刚毕业的时候，先是去做j2ee开发，后来糊里糊涂地进入了现在的公司做手机软件开发，公司以前用的体系架构是在polish的基础上改造的，与polish 有很多的相似之处。当时在学习polsih的时候感觉很是费劲，在开始几个月时间里，公司没有安排什么像样的活，最多就是写个控件，好几个月下来对polish的认识还是一头雾水，后来自己利用工作之余认认真真的看了关于polish的各方面的资料，感觉polish也就那样子，下面说说自己的一点看法。

polish的架构可以从下面的方面来理解：polish主要是理解了Screen,其它的就很简单了。

Screen的理解。

第一，由里到外-----分层。

第二，在分层的基础上，由上之下布局。

怎么讲？

分层：第一层是背景层，第二层是跟container平行的层，第三层：浮动信息层。

由上到下布局主要看第二层：title、subTitle(tabBar)、container、menubar，第一层背景没有什么可说的。

第三层：浮动信息层，可以用该层来显示一些提示框使用，如：输入法的显示等等。

就这么简单，也许有人会说polish里面的Form之类的类，其实这些类很简单的，Form没有什么内容，它只是对Screen的一个包装，来对外提供一下接口而已。

至于这些组件的响应也就是根据分层的逆推回思想去的做各个层面的控件响应的。

个人觉得有了上面的思想学习polish是件非常简单的事。

polish给我们提供了很多很好的UI组件，我们学习的过程中可以劲情的享受，当然也要取之精华，去之糟粕，因为polish是面向大众的，它相应的逻辑处理也就很复杂，我们可以结合它优点，去掉繁琐的地方，自己写适合自己UI控件。

欢迎大家说出自己的学习心得，一起学习一起提高。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

德鲁克日志读后感之五十二

wainwen — Fri, 25 Jul 2008 12:52:12 +0800

作者: wainwen 链接：http://wainwen.javaeye.com/blog/219449 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

引用

二月二十四日企业的合法性

除非企业权力的组建是建立在一个能为人接受的合法性原则基础上，否则它将无法存在。

任何社会权利只要丧失了合法性，就不能持久维系。任何社会若不能将个体成员凝聚起来，也不能发挥功效。我们的社会若不能使工业体系的成员得到他们今天所缺乏的地位与职能，也将走向解体。大多数人不会造反，反而会陷入一种麻木不仁的状态。他们将会逃避自由的责任，这种丧失了社会意义的自由只是一种威胁与负担。我们只有两个选择：要么建立一个有效的工业社会，要么就是眼睁睁地看着自由湮没于无政府与暴政之中。

行动指南：
决定你和你的公司是在一个无政府或暴政的世界中运营，还是在一个风险极高的环境中运营。

摘自：

彼得.德鲁克《工业人的未来》（The Future of Industrial Man）

评注：

本篇日志源自《工业人的未来》第4章“20世纪的工业现实”第3节的最后两段。不仔细阅读原书整个章节，将很难准确把握德鲁克的本意。

“合法性”对应“Legitimacy”，从上下文看，此处解释为“合理性”更贴近原意。德鲁克认为，20世纪的工业社会遇到了很大危机，虽然大部分人都获得了经济保障，经济满足也确实是社会稳定的基础，但是单纯的经济满足，会给社会和政治带来消极影响。解决这个问题，需要从工业社会过渡到功能社会，其先决条件之一，是个人和社会的相互融合。粗略地说，当个人真正融入社会之中，成为社会的主人，不再是游离于主流社会的旁观者，就能主动承担起更多的责任，人和社会才能和谐共存。

牛根生在论述“承担社会责任是企业的第一要务”时，给出了五个要点：无责任则无品牌，不承担责任的品牌大不了；大品牌伴随大监督；大品牌关联大市场，与整个行业共进退，就要承担更大的责任；大责任通向大舞台，责任有多大舞台就有多大；大品牌责系大人群等等。

谈论社会责任，容易被指责为做秀，其实这更加昭示着一个企业家的视野和格局。无论是巧取豪夺，还是诚信务实，企业要想永续经营，终归要和社会和睦相处。企业承担更多社会责任，融于所处的社区和社会之中，这是企业存在和发展的“合理性”。

员工之于企业，和企业之于社会，有很多相似之处。薪水是员工稳定的基础，但是单纯的经济满足，很容易让员工成为企业的旁观者。得过且过，缺乏激情和效率，最终演变为劳资之间的对抗和对立。这是一个双输的结果，企业一无所得，员工职业失败。

要避免员工麻木不仁，最有效的方法，就是让员工真正融入企业之中。和企业相融，才能承担更多责任，焕发更多热情。淘宝网在招聘启示中说“来加入我们吧！如果你接受我们的苦和乐，如果你想战斗而不是糊口！”。连糊口都不屑考虑，一心一意渴望战斗，真要建立了这样一支队伍，有什么事业不敢去做呢。

企业的社会责任，靠企业家的心智和视野；员工的企业责任，靠什么来引导呢。是企业的使命，还是管理者的个人魅力；是高薪加期权，还是大棒加忽悠？估计没有谁能给出明确的答案。或许，失败的企业总是相似的，成功的企业各有各的高招。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

haproxy支持4层交换的规则了

mryufeng — Fri, 25 Jul 2008 12:23:03 +0800

作者: mryufeng 链接：http://mryufeng.javaeye.com/blog/219434 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

July 20th, 2008 : two lines...

Two lines... That's all what is needed with the new TCP content inspection system to stop half of the spams I got home. One of my major customers who uses HAProxy a lot has sponsored the development of some preliminary content inspection which is used to decide whether to forward a connection or not. The very first usage of this feature consists in checking that only SSL is spoken on a connection. But most likely more protocols will come soon. As a nice side effect, I could now add a delay before the HELO message of my SMTP server, and reject all robots which talk first (forbidden). And since many spam bots have small timeout values, many of them abort before the timeout is reached, resulting in my incoming spam rate dropping from about 300/hour to "only" 150/hour. Those who keep up with the time out slow down due to limited resources. The small addition simply consists in adding those two lines in the frontend :

tcp-request inspect-delay 35s
tcp-request content reject if REQ_CONTENT

在process_cli中增加了一个状态CL_STINSPECT用于处理4层数据规则的状态，这样就很容易根据tcp的内容做判断决定拒绝连接或者如何转发后端等事务。
强！
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

电子书更新(Spring,Hibernate,Django,Terracot 2008-07-25）

iMzw — Fri, 25 Jul 2008 11:35:11 +0800

作者: iMzw 链接：http://nealmi.javaeye.com/blog/219396 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

PS:如无特殊说明以下都为英文版。

如果有能力，请尽量购买纸板书籍。

Spring & Hibernate

(2008-07-25 Update)

APRESS.Terracotta.2008.PDF

Apress_Spring_Recipes_Jun_2008.PDF

OReilly_Harnessing_Hibernate_Apr_2008.zip

Flex ActionScript

Wiley.ActionScript.3.0.Bible.Oct.2007.pdf

(2008-06-08 Update)

Advanced ActionScript 3 with Design Patterns - 2006 (Adobe).chm.zip

OReilly.ActionScript.3.0.Cookbook.Oct.2006.chm.zip

Groovy & Grails

(2008-07-25 Update)

Apress_Beginning_Groovy_and_Grails_Jun_2008.PDF

(initial)

The.Definitive.Guide.to.Grails.Dec.2006.eBook-BBL .pdf

TheDefinitiveGuideToGrails1590597583SourceCode.zip

Groovy.Programming.Dec.2006.eBook-BBL.pdf

Groovy.in.Action.Jan.2007.eBook-BBL.pdf

Design Pattern

(2008-06-08 Update)

O'Reilly - Head First Object-Oriented Design and Analysis.pdf

Python / Django

(2008-07-25 Update)

Apress_Practical_Django_Projects_Jun_2008.PDF

Other

(initail)

OReilly.Beautiful.Code.Jun.2007.pdf

Pragmatic.Release.It.Design.and.Deploy.Production.Ready.Software.Apr.2007.eBook-BBL

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

JAVA面试题解惑系列（八）——聊聊基本类型（内置类型）

臧圩人 — Fri, 25 Jul 2008 10:24:25 +0800

作者: 臧圩人链接：http://zangweiren.javaeye.com/blog/219369 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

作者：臧圩人（zangweiren）
网址：http://zangweiren.javaeye.com

>>>转载请注明出处！<<<

基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。

基本类型共有八种，它们分别都有相对应的包装类。关于它们的详细信息请看下表：

基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类java.lang.Void，不过我们无法直接对它们进行操作。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：

public class PrimitiveTypeTest {
	public static void main(String[] args) {
		// byte
		System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
		System.out.println("包装类：java.lang.Byte");
		System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
		System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
		System.out.println();

		// short
		System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
		System.out.println("包装类：java.lang.Short");
		System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
		System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
		System.out.println();

		// int
		System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
		System.out.println("包装类：java.lang.Integer");
		System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
		System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
		System.out.println();

		// long
		System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
		System.out.println("包装类：java.lang.Long");
		System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
		System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
		System.out.println();

		// float
		System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
		System.out.println("包装类：java.lang.Float");
		System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
		System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
		System.out.println();

		// double
		System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
		System.out.println("包装类：java.lang.Double");
		System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
		System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
		System.out.println();

		// char
		System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
		System.out.println("包装类：java.lang.Character");
		// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
		System.out.println("最小值：Character.MIN_VALUE="
				+ (int) Character.MIN_VALUE);
		// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
		System.out.println("最大值：Character.MAX_VALUE="
				+ (int) Character.MAX_VALUE);
	}
}

运行结果：

基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。

大家将运行结果与上表信息仔细比较就会发现float、double两种类型的最小值与Float.MIN_VALUE、Double.MIN_VALUE的值并不相同，这是为什么呢？实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是float和double类型所能表示的最小正数。也就是说存在这样一种情况，0到±Float.MIN_VALUE之间的值float类型无法表示，0到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0（1.5）开始，JAVA虚拟机（Java Virtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

各种数值类型之间的赋值与转换遵循什么规律呢？我们来看下面这个例子：

public class PrimitiveTypeTest {
	public static void main(String[] args) {
		// 给byte类型变量赋值时，数字后无需后缀标识
		byte byte_a = 1;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// byte byte_b = 1000;
		// 把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
		// byte byte_c = 1L;

		// 给short类型变量赋值时，数字后无需后缀标识
		short short_a = 1;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// short short_b = 70000;
		// 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围
		// byte short_c = 1L;

		// 给short类型变量赋值时，数字后无需后缀标识
		int int_a = 1;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// int int_b = 2200000000;
		// 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围
		// int int_c = 1L;

		// 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识
		long long_a = 1;
		// 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识
		long long_b = 2200000000L;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// long long_c = 9300000000000000000L;

		// 可以把一个int型值直接赋值给float型变量
		float float_a = 1;
		// 可以把一个long型值直接赋值给float型变量
		float float_b = 1L;
		// 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量
		// float float_c = 1.0;
		// float型数值需要有一个F（不区分大小写）后缀标识
		float float_d = 1.0F;
		// 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围
		// float float_e = 1.0D;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// float float_f = 3.5000000E38F;

		// 可以把一个int型值直接赋值给double型变量
		double double_a = 1;
		// 可以把一个long型值直接赋值给double型变量
		double double_b = 1L;
		// 可以把一个float型值直接赋值给double型变量
		double double_c = 1F;
		// 不带后缀标识的浮点数默认为double类型的，可以直接赋值
		double double_d = 1.0;
		// 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的
		double double_e = 1.0D;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// double double_f = 1.8000000000000000E308D;

		// 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
		// byte byte_d = 1.0D;
		// 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围
		// short short_d = 1.0D;
		// 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围
		// int int_d = 1.0D;
		// 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围
		// long long_d = 1.0D;

		// 可以用字符初始化一个char型变量
		char char_a = 'a';
		// 也可以用一个int型数值初始化char型变量
		char char_b = 1;
		// 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
		// char char_c = 1L;
		// 把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
		// char char_d = 1.0F;
		// 把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
		// char char_e = 1.0D;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// char char_f = 70000;
	}
}

从上面的例子中我们可以得出如下几条结论：

未带有字符后缀标识的整数默认为int类型；未带有字符后缀标识的浮点数默认为double类型。
如果一个整数的值超出了int类型能够表示的范围，则必须增加后缀“L”（不区分大小写，建议用大写，因为小写的L与阿拉伯数字1很容易混淆），表示为long型。
带有“F”（不区分大小写）后缀的整数和浮点数都是float类型的；带有“D”（不区分大小写）后缀的整数和浮点数都是double类型的。
编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查，如果超出了它们的取值范围就会报错。
int型值可以赋给所有数值类型的变量；long型值可以赋给long、float、double类型的变量；float型值可以赋给float、double类型的变量；double型值只能赋给double类型变量。

下图显示了几种基本类型之间的默认逻辑转换关系：

图中的实线表示无精度损失的转换，而虚线则表示这样的转换可能会损失一定的精度。如果我们想把一个能表示更大范围或者更高精度的类型，转换为一个范围更小或者精度更低的类型时，就需要使用强制类型转换（Cast）了。不过我们要尽量避免这种用法，因为它常常引发错误。请看下面的例子，如果不运行代码，你能预测它的结果吗？

public class PrimitiveTypeTest {
	public static void main(String[] args) {
		int a = 123456;
		short b = (short) a;
		// b的值会是什么呢？
		System.out.println(b);
	}
}

运行结果：

-7616

运算符对基本类型的影响

当使用+、-、*、/、%运算符对基本类型进行运算时，遵循如下规则：

只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型；
否则，只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型；
否则，只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型；
否则，两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。

当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时，遵循如下规则：

运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型，然后再执行运算，且运算结果与运算符右边数值类型相同。

了解了这些，我们就能解答下面这个常考的面试题了。请看：

引用

short s1=1;s1=s1+1;有什么错？short s1=1;s1+=1;有什么错？

乍一看，觉得它们都应该没有错误，可以正常运行。我们来写个例子试试：

public class PrimitiveTypeTest {
	public static void main(String[] args) {
		short s1 = 1;
		// 这一行代码会报编译错误
		// s1 = s1 + 1;
		// 这一行代码没有报错
		s1 = 1 + 1;
		// 这一行代码也没有报错
		s1 += 1;
	}
}

从例子中我们可以看出结果了。利用上面列举的规律，也很容易解释。在s1=s1+1;中，s1+1运算的结果是int型，把它赋值给一个short型变量s1，所以会报错；而在s1+=1;中，由于是s1是short类型的，所以1首先被强制转换为short型，然后再参与运算，并且结果也是short类型的，因此不会报错。那么，s1=1+1;为什么不报错呢？这是因为1+1是个编译时可以确定的常量，“+”运算在编译时就被执行了，而不是在程序执行的时候，这个语句的效果等同于s1=2，所以不会报错。前面讲过了，对基本类型执行强制类型转换可能得出错误的结果，因此在使用+=、-=、*=、/=、%=等运算符时，要多加注意。

Math.round()方法

java.lang.Math类里有两个round()方法，它们的定义如下：

public static int round(float a) {
    //other code
}

public static long round(double a) {
    //other code
}

它们的返回值都是整数，且都采用四舍五入法。运算规则如下：

如果参数为正数，且小数点后第一位>=5，运算结果为参数的整数部分+1。
如果参数为负数，且小数点后第一位>5，运算结果为参数的整数部分-1。
如果参数为正数，且小数点后第一位<5；或者参数为负数，且小数点后第一位<=5，运算结果为参数的整数部分。

我们可以通过下面的例子来验证：

public class MathTest {
	public static void main(String[] args) {
		System.out.println("小数点后第一位=5");
		System.out.println("正数：Math.round(11.5)=" + Math.round(11.5));
		System.out.println("负数：Math.round(-11.5)=" + Math.round(-11.5));
		System.out.println();

		System.out.println("小数点后第一位<5");
		System.out.println("正数：Math.round(11.46)=" + Math.round(11.46));
		System.out.println("负数：Math.round(-11.46)=" + Math.round(-11.46));
		System.out.println();

		System.out.println("小数点后第一位>5");
		System.out.println("正数：Math.round(11.68)=" + Math.round(11.68));
		System.out.println("负数：Math.round(-11.68)=" + Math.round(-11.68));
	}
}

运行结果：

小数点后第一位=5
正数：Math.round(11.5)=12
负数：Math.round(-11.5)=-11
小数点后第一位<5
正数：Math.round(11.46)=11
负数：Math.round(-11.46)=-11
小数点后第一位>5
正数：Math.round(11.68)=12
负数：Math.round(-11.68)=-12

根据上面例子的运行结果，我们还可以按照如下方式总结，或许更加容易记忆：

参数的小数点后第一位<5，运算结果为参数整数部分。
参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正负）不变。
参数的小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。

switch语句

哪些类型可以用于switch语句的判断呢？我们做个测试就知道了：

public class MathTest {
	// 枚举类型，Java5.0以上版本可用
	static enum enum_e {
		A, B
	}

	public static void main(String[] args) {
		// byte
		byte byte_n = 0;
		switch (byte_n) {
		case 0:
			System.out.println("byte可以用于switch语句");
			break;
		}

		// Byte类
		Byte byte_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (byte_m) {
		case 0:
			System.out.println("Byte类可以用于switch语句");
			System.out.println();
			break;
		}

		// char
		char char_n = 0;
		switch (char_n) {
		case 0:
			System.out.println("char可以用于switch语句");
			break;
		}

		// Character类
		Character char_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (char_m) {
		case 0:
			System.out.println("Character类可以用于switch语句");
			System.out.println();
			break;
		}

		// short
		short short_n = 0;
		switch (short_n) {
		case 0:
			System.out.println("short可以用于switch语句");
			break;
		}

		// Short
		Short short_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (short_m) {
		case 0:
			System.out.println("Short类可以用于switch语句");
			System.out.println();
			break;
		}

		// int
		int int_n = 0;
		switch (int_n) {
		case 0:
			System.out.println("int可以用于switch语句");
			break;
		}

		// Integer类
		Integer int_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (int_m) {
		case 0:
			System.out.println("Integer类可以用于switch语句");
			System.out.println();
			break;
		}

		// long
		long long_n = 0;
		// 编译错误，long型不能用于switch语句
		// switch (long_n) {
		// case 0:
		// System.out.println("long可以用于switch语句");
		// break;
		// }

		// Long类
		Long long_m = 0L;
		// 编译错误，Long类型不能用于switch语句
		// switch (long_m) {
		// case 0:
		// System.out.println("Long类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// float
		float float_n = 0.0F;
		// 编译错误，float型不能用于switch语句
		// switch (float_n) {
		// case 0.0F:
		// System.out.println("float可以用于switch语句");
		// break;
		// }

		// Float类
		Float float_m = 0.0F;
		// 编译错误，Float类型不能用于switch语句
		// switch (float_m) {
		// case 0.0F:
		// System.out.println("Float类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// double
		double double_n = 0.0;
		// 编译错误，double型不能用于switch语句
		// switch (double_n) {
		// case 0.0:
		// System.out.println("double可以用于switch语句");
		// break;
		// }

		// Double类
		Double double_m = 0.0;
		// 编译错误，Double类型不能用于switch语句
		// switch (double_m) {
		// case 0.0:
		// System.out.println("Double类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// boolean
		boolean bool_b = true;
		// 编译错误，boolean型不能用于switch语句
		// switch (bool_b) {
		// case true:
		// System.out.println("boolean可以用于switch语句");
		// break;
		// }

		// Boolean类
		Boolean bool_l = true;
		// 编译错误，Boolean类型不能用于switch语句
		// switch (bool_l) {
		// case true:
		// System.out.println("Boolean类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// String对象
		String string_s = "Z";
		// 编译错误，long型不能用于switch语句
		// switch (string_s) {
		// case "Z":
		// System.out.println("String可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// enum（枚举类型，Java5.0以上版本可用）
		switch (MathTest.enum_e.A) {
		case A:
			System.out.println("enum可以用于switch语句-A");
			break;
		case B:
			System.out.println("enum可以用于switch语句-B");
			break;
		}
	}
}

运行结果如下：

byte可以用于switch语句
Byte类可以用于switch语句
char可以用于switch语句
Character类可以用于switch语句
short可以用于switch语句
Short类可以用于switch语句
int可以用于switch语句
Integer类可以用于switch语句
enum可以用于switch语句-A

结果已经出来了，我们来总结一下：

byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持）都可以用于switch语句。
long、float、double、boolean四种基本类型以及它们的包装类（在Java所有版本中）都不能用于switch语句。
enum类型，即枚举类型可以用于switch语句，但是要在Java5.0（1.5）版本以上才支持。
所有类型的对象（包括String类，但在Java5.0/1.5以上版本中，该项要排除byte、char、short、int四种基本类型对应的包装类）都不能用于switch语句。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

lucene 处理一对多关系

hqman — Fri, 25 Jul 2008 09:55:06 +0800

作者: hqman 链接：http://hqman.javaeye.com/blog/219337 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

项目开发中碰到这样一个问题：

 一个人有多种职业 教师（123），程序员（456）。 我要搜索 所有是 教师的人，或者是 教师 又是程序员的人。

解决：

只要职业对应 job字段多放几个Term，然后在搜索的时候用 job：＋123 or job：＋123 ＋456，就可以找出相应的人

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

New version of the Groovy Eclipse plugin

masterkey — Fri, 25 Jul 2008 09:22:43 +0800

作者: masterkey 链接：http://masterkey.javaeye.com/blog/219326 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Groovy Eclipse plugin已经更新。已经采用了Groovy 1.5.6,同时支持Eclipse3.4

zip:
http://dist.codehaus.org/groovy/distributions/update/GroovyEclipse.zip

online update:
http://dist.groovy.codehaus.org/distributions/update/

Upcoming version of the plugin will feature the first refactorings
(extract method).
You can discover more on the topic thanks to the students working on
this project as part of their Bachelor thesis at University of applied
sciences, in Rapperswil, Switzerland, here:
http://sifsstud4.hsr.ch/trac/GroovyRefactoring

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

代码写来是用来读的

Goodtiger — Fri, 25 Jul 2008 09:05:43 +0800

作者: Goodtiger 链接：http://goodtiger.javaeye.com/blog/219315 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天读了一些业务相关的代码，有一个类的方法达到了400多行，里面很多的判断语句，最多的if嵌套深度到达了5层，其实整个方法的业务逻辑并不是很复杂，就是对调用请求进行一些检查，然后在每种情况下进行一些不同的处理，而且这些处理都比较的简单，但是糅合在一起的代码。却很多的问题
一、很难直白的理解方法的意图
    虽然你可以从if语句的判断条件中读懂整个执行流程，但是这还是很费力的，如果碰到变量名取得不好，或者if判断中间是N个条件的组合判断，你就很难读了。
二、为方法增加新的逻辑之后就很困难而且容易出错
    在众多的判断逻辑中要增加新的逻辑，最大的成本在于你要先读懂原有逻辑，最好是画出原有方法的顺序图，然后基于这个顺序图再来添加新的逻辑，但是基本上是不会有人这么做的，所以添加新的逻辑处理的时候，就基本上是Bug数量迅速增长的时候。
三、方法难以测试
    因为判断逻辑很多，导致代码的执行路径很多，在编写测试用例的时候，做到路径覆盖也是很困难的。而且一旦方法的处理逻辑改变了比较大，基本上所有的测试用例都得重写。
问题肯定还是很多的，简单的重构的方向
一、将判断逻辑封装成方法
    这是最直接的想法，其实就是将复杂的处理逻辑分解成一个个小方法，然后再拼装起来，这样就可以克服上述3个缺点，如果封装的方法名取得得当，那么你就不需要读懂if的复杂判断语句来理解方法所表达的业务处理逻辑，与此代码的增加新的逻辑就简单了，在较小的方法中进行修改就相对容易多了，但并不是绝对的。
二、利用面向对象进行更深层次的封装
    如果代码中到处都是if的判断语句，那显然是面向过程的痕迹很重，我们可以深入的分析，将设计变得更加面向对象，对对象职责的细分，对象方法处理逻辑的简化，对象之间的交互更简单直接些。其实这未必更加简单，需要付出的设计、重构的代价也很大。理解更多的对象之间的交互也不是一件简单的事情，但是在可扩展性方面就更好。

    没有拿实例代码来说明，但是道理还是很简单的，如果想要较小的成本在短时间内进行重构，那么就采用第一种方法，将判断逻辑封装成方法。想要在一个大的系统内得到更好的重构效果，就要重新考虑设计，进行设计到代码两层次的重构。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

DOM 模型和 Prototype

sunfengcheng — Fri, 25 Jul 2008 08:13:22 +0800

作者: sunfengcheng 链接：http://sunfengcheng.javaeye.com/blog/219307 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

今天介绍一下 DOM 模型和 Prototype框架的一些对象和类，
什么是 DOM模型 --Document Object Module 就是文档对象类型，可以看成是结构化的树形的数据
，闲言少叙书归正传，下面是我最近学习js搜集到的一些document的方法，很实用的。下面将介绍它包含的对象方法。

Element对象的方法：

visible: function(element)：判断element是否可见, 参数element可以是元素本身或元素id(下面的方面的参数基本上都是这样的)

toggle: function(element)：反转element的可见性

hide: function(element)：隐藏元素

show: function(element)：显示元素

remove: function(element)：移除元素

update: function(element, html) ：使用html更新element的内容，html中的script会执行(下同)

replace: function(element, html)：将element替换为html

inspect: function(element)：element的字符串表示

Element对象的方法：

visible: function(element)：判断element是否可见, 参数element可以是元素本身或元素id(下面的方面的参数基本上都是这样的)

toggle: function(element)：反转element的可见性

hide: function(element)：隐藏元素

show: function(element)：显示元素

remove: function(element)：移除元素

update: function(element, html) ：使用html更新element的内容，html中的script会执行(下同)

replace: function(element, html)：将element替换为html

inspect: function(element)：element的字符串表示

up(element, expression, index)：利用Selector.findElement方法找到element元素的祖先节点中符合表达式expression的所有元素组成的数组索引为index的元素，也可以忽略expression(默认为*，表示匹配所有元素)和index(默认为0)，直接这样调用up(element, index)或up(element)

down(element, expression, index)：跟up一样，只是返回的是子孙节点

previous(element, expression, index)：返回前面的兄弟节点

next(element, expression, index)：返回后面的兄弟节点

getElementsBySelector(element,args)：Selector.findChildElements(element, args)的封装，args表示可以传递多个参数，每个参数是一个css selector表达式，返回element的子孙节点中符合任何一个css selector表达式的元素组成的数组

getElementsByClassName(element, className)：返回element中的子孙节点中符合clsssName的元素

hasClassName: function(element, className) ：判断element是否含有className

addClassName: function(element, className) ：给element添加一个class

removeClassName: function(element, className) ：移除元素中的一个class

observe()：调用Event对象(Prototype中的，将在后面介绍)的observe方法为元素注册事件handle

stopObserving() ：移除注册的事件handle

cleanWhitespace: function(element)：移除元素中空白的文本子节点

empty: function(element)：判断元素是否为空

childOf: function(element, ancestor) ：判断element是否为ancestor的子孙节点

scrollTo: function(element) ：滚动条移动到元素所在的地方

getStyle: function(element, style) ：得到元素某个css样式的值，例如$(element).getStyle("float")

setStyle: function(element, style) ：设置元素的css样式，style十一个对象，例如element.setStyle({left: "40px", "background-color":"#666"})

getDimensions: function(element) ：得到元素的尺寸，即使元素是隐藏的也可以正确的返回，返回 return {width: originalWidth, height: originalHeight}这样的关联数组

makePositioned: function(element) ：当元素的position css属性为static或不存在使，将次属性更改为relative

undoPositioned: function(element) ：跟makePositioned相反的操作

makeClipping: function(element) ：把元素变成clipping(切片)，也就是设置元素的overflow属性为hidden

undoClipping: function(element)：反转上面的方法对元素所做的修改

hasAttribute(element)：判断元素是否有某个属性

Insertion.Before：将内容插入到元素的前面，内容在元素外面

Insertion.Top：将内容插入到元素的顶部，内容在元素里面

Insertion.Bottom：将内容插入到元素的底部，内容在元素里面

Insertion.After：将内容插入到元素后面，内容在元素外面

以上的这些方法经常会使用到的，不过里面有很多方法我也没有使用过，有些是在网上搜集的，有的是在书上找到的，里面有很多在最近制作google日历时用到了，在js创建表格，div什么虽然具有挑战，比起其他使用起来麻烦多了，但是很有逻辑性的。
希望上面能给JavaScript的学习使用的同仁带来方便，这里可是实现Ajax的关键因素。

提供给大家参考学习，这是经常用到的。
本文的讨论也很精彩，浏览讨论>>

JavaEye推荐

Flex 开发架构(一): 混沌未开－Flex-all-in-one

houwei — Fri, 25 Jul 2008 03:44:44 +0800

作者: houwei 链接：http://houwei.javaeye.com/blog/219304 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

混沌未开，顾名思义就是匹萨店里面烘烤的色香味俱全的一个pizza大饼，在一个面饼的底板上，混合所有的原料。 Lets make Pizza!

Flex与生俱来的是它的事件驱动（event-driven）的特点。就是说，Flex可以使用它的标签做到任何事情。因此开发一个Flex应用程序最简单，最基础的方法就是使用Flex标签，先来看看代码。

Loginview，用户界面部分：

使用标签调用远程服务：


    
     
      {username.text}
      {password.text}

现在，在login方法中发送请求：

   if(Validator.validateAll(validators).length == 0){
     loginReq.login.send();
   }

在发送请求之后，需要建立一个返回结果的处理方法：

  private function  loginHandler(event:ResultEvent):void{
    var isLogin:Boolean = event.result as Boolean;
   if(isLogin){
    this.parentApplication.viewStack.selectedIndex=1;
    dispatchEvent(new LoginUserEvent(username.text));
   }
  }

最后，在页面之间建立联系，在这里我使用播送事件：

dispatchEvent(new LoginUserEvent(username.text));

播送用户自定义的事件，就必须在代码最前面写入下述的元标签代码：

 
     [Event(name="loginUser", type="flash.events.Event")]

 

 
然后，建立用户自定义的事件LoginUserEvent.as:

 
import flash.events.Event;
 public class LoginUserEvent extends Event
 {
  public static const LOGINUSEREVENT:String =”loginUser”;
  public var loginUserName:String = “”;
  
  public function LoginUserEvent(userName:String)
  {
   super(LOGINUSEREVENT, true, true);
   this.loginUserName = userName;
  }
  override public function clone():Event {
     
      return new LoginUserEvent(loginUserName);
     
   }

 

 
当登录成功后，密友列表页面将会显示，BuddyListVew.mxml：
重要的是在列表代码中，首先要监听LoginUserEvent，因此要创建一个preinitialize的方法：

 

   private function init():void{
   this.parentApplication.addEventListener(LoginUserEvent.LOGINUSEREVENT, getUserName);
 }

 

 
然后完成事件监听的管理程序：

 
private function getUserName(event:LoginUserEvent):void{
loginUserName = event.loginUserName;
loginReq.getAllFriends.send();
}

 

 
发送获得全部密友列表的请求，并且创建对应的管理方法：

   private function getAllFriendsHandler(event:ResultEvent):void{
   mybuddyList = event.result as ArrayCollection;
   
  }

 

在代码中，必须包含定义远程对象的标签：


    
     
      {loginUserName}
     
    


  



 

 

 

 

 

使用Flex标签完成程序方法非常简单，并且对于简单的系统来说， 也是非常有效，其商务逻辑层也不复杂。但在实际的应用中，并非只存在这样的项目，相反，实际工作中往往需要大量的远程对象的通讯。


 

好了，来看看：中央管理－Flex Central Management.


 

 


 



 
 
 
 
 




 


 

 
          

          
            本文的讨论也很精彩，浏览讨论>>
          
          



          JavaEye推荐
          

          北京: 千橡集团暨校内网诚聘软件研发工程师
搜狐网站诚聘Java、PHP和C++工程师

某互联网广告分析公司招聘软件工程师的面试题

liuming — Fri, 25 Jul 2008 02:19:19 +0800

作者: liuming 链接：http://liuming.javaeye.com/blog/219296 发表时间: 2008年07月25日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1. 现有的系统和数据库中有一张产品数据表products，有例如id,name,price,catagory等一系列固有的字段。当然还有用户数据表users。用户可以查看自己添加的产品，现在需要加上一个功能，使得用户可以在自己的产品查看界面中，为产品增加自定义的字段。比如，一个用户需要增加一个字段，记录每种产品的货源地。请给出数据库的解决方案，例如要添加或修改哪些字段或表。

2. 承接上题，请写出SQL，查询出某用户的产品和及其自定义的产品字段的全部信息。

3. 网页中有一个文本域控件，一个按钮控件和一个文本框控件。问题一，请写出原生JavaScript代码，使得点击按钮时，文本域内的字符添加到文本框中。问题二，如果把文本框换成div，请给出实现相同功能的原生JavaScript代码。

4. 磁盘中有一个文本文件list.txt，保存了用户自己的产品数据，其文件体积不确定，可能2G，也可能200byte。文件格式类似如下格式：

"name", "price", "description"

"iPod", "200.00","good player"

"dvd player", "109.99","bad thing"

..................

请给出程序代码，读取这个文件，并把每条数据和个数据项插入到数据库中。可在Perl，Python，PHP，C或者Ruby语言中任选一种实现。

5. 请说出以下代码的运行结果

6. 有一个套广告管理系统，用户登陆后发现显示数据等大部份操作都很慢，而目前尚未确定问题的原因。请你给你假设一些内部和外部条件，说说你排查问题的思路。

本文的讨论也很精彩，浏览讨论>>

JavaEye推荐