BlogJava-藏经阁-文章分类-Web开发http://www.blogjava.net/zhouf/category/45694.htmlzh-cnMon, 01 Jul 2019 23:10:32 GMTMon, 01 Jul 2019 23:10:32 GMT60使用Maven创建项目模板http://www.blogjava.net/zhouf/articles/433940.htmlZhouFengZhouFengMon, 24 Jun 2019 02:55:00 GMThttp://www.blogjava.net/zhouf/articles/433940.htmlhttp://www.blogjava.net/zhouf/comments/433940.htmlhttp://www.blogjava.net/zhouf/articles/433940.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/433940.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/433940.html在开发项目的时候，有许多项目结构都是差不多的，使用的框架也一样，spring配置文件也一样的，只是每个项目的名称，包名等不同，如果按照之前的方法，可以拷贝一个项目，然后再做一些修改就好了。这也不是不可以，只是我觉得，应该还有更帅的招，Maven可以使用archetype创建项目，那是否也可以创建自定义结构的项目了，所以就了解了一下通过Maven使用现有项目创建项目模板。尝试了一下，很不错，可以自动处理包名等转换，几个命令就可以生成雷同结构的项目，在此记录一下过程

1 准备好一个现有的项目

既然做为模板项目，里面的配置都是做好了的，是一个可以用的项目，加入了Eclipse支持，项目中包含一些Eclipse配置文件，本例中项目目录为
D:\workspace\myprj

2 创建模板工程

进入项目目录后，运行生成archetype命令
D:\workspace\myprj>mvn archetype:create-from-project
会在myprj目录下生成target目录，其下生成如下目录
classes
generated-sources
generated-test-sources
m2e-wtp
maven-status
surefire-reports
test-classes
模板代码主要位于generated-sources目录中

3 修改模板代码

项目中的所有代码都会自动替换为占位符，除了Eclipse配置文件之外，接下来修改模板，进入target\generated-sources\archetype\src\main\resources\archetype-resources\目录，将Eclipse配置文件也加入占位符，以方便新项目的生成，比如修改下面两个文件，加入占位符artifactId
文件1：.project
#set( $symbol_pound = '#' )
#set( $symbol_dollar = '$' )
#set( $symbol_escape = '\' )
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
        <name>${artifactId}</name>
        <comment></comment>
        <projects>
        </projects>
        <buildSpec>
                <buildCommand>
                        <name>org.eclipse.jdt.core.javabuilder</name>
                        <arguments>
                        </arguments>
                </buildCommand>
                <buildCommand>
                        <name>org.eclipse.wst.common.project.facet.core.builder</name>
                        <arguments>
                        </arguments>
                </buildCommand>
                <buildCommand>
                        <name>org.eclipse.wst.validation.validationbuilder</name>
                        <arguments>
                        </arguments>
                </buildCommand>
                <buildCommand>
                        <name>org.eclipse.m2e.core.maven2Builder</name>
                        <arguments>
                        </arguments>
                </buildCommand>
        </buildSpec>
        <natures>
                <nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
                <nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
                <nature>org.eclipse.jdt.core.javanature</nature>
                <nature>org.eclipse.m2e.core.maven2Nature</nature>
                <nature>org.eclipse.wst.common.project.facet.core.nature</nature>
                <nature>org.eclipse.wst.jsdt.core.jsNature</nature>
        </natures>
</projectDescription>
文件2：.settings\org.eclipse.wst.common.component
<?xml version="1.0" encoding="UTF-8"?><project-modules id="moduleCoreId" project-version="1.5.0">
    <wb-module deploy-name="${artifactId}">
        <wb-resource deploy-path="/" source-path="/target/m2e-wtp/web-resources"/>
        <wb-resource deploy-path="/" source-path="/src/main/webapp" tag="defaultRootSource"/>
        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/java"/>
        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/resources"/>
        <property name="context-root" value="${artifactId}"/>
        <property name="java-output-path" value="/${artifactId}/target/classes"/>
    </wb-module>
</project-modules>

4 修改项目文件列表

配置完成后，通过mvn生成新的项目时，上面的Eclipse配置文件也不会被放入新的工程里，需要在配置文件中加入这些文件的信息，以及标记哪些文件是需要使用占位符替换的，修改target\generated-sources\archetype\src\main\resources\META-INF\maven\archetype-metadata.xml文件，在现有文件中可以看到如下信息
<fileSet filtered="true" encoding="UTF-8">
    <directory>.settings</directory>
    <includes>
        <include>**/*.xml</include>
    </includes>
</fileSet>
也就是说，默认情况下，mvn只将.settings目录下的*.xml文件生成到项目中，其中filtered="true"表示需要进行内容过滤替换占位符，我们把需要添加的文件放入此配置，修改后结果如下
<fileSet filtered="true" encoding="UTF-8">
    <directory>.settings</directory>
    <includes>
        <include>**/*.xml</include>
        <include>**/*.container</include>
        <include>**/*.component</include>
        <include>**/*.name</include>
        <include>**/*.jsdtscope</include>
        <include>**/*.prefs</include>
    </includes>
</fileSet>
<fileSet filtered="true" encoding="UTF-8">
    <directory></directory>
    <includes>
        <include>.classpath</include>
        <include>.project</include>
    </includes>
</fileSet>
如果需要过滤掉一些不需要的文件，也可以在此配置。准备好后，就可以安装了

5 将模板项目安装到本地仓库

进入/target/generated-sources/archetype/目录，执行安装
D:\workspace\myprj\target\generated-sources\archetype>mvn install
此命令会在maven仓库中生成archetype-catalog.xml文件，仓库位置取决于maven配置文件settings.xml中的设置，内容如下，可以修改描述信息，方便在创建项目时进行提示
<?xml version="1.0" encoding="UTF-8"?>
<archetype-catalog xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-catalog/1.0.0 http://maven.apache.org/xsd/archetype-catalog-1.0.0.xsd"
    xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-catalog/1.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <archetypes>
    <archetype>
      <groupId>com.zhouf</groupId>
      <artifactId>myprj-archetype</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <description>simple project with springmvc and jetty</description>
    </archetype>
  </archetypes>
</archetype-catalog>

6 创建项目测试

执行生成命令
D:\workspace>mvn archetype:generate -DarchetypeCatalog=local
此命令可以在任何目录下执行，会在当前目录生成项目
Choose archetype:
1: local -> com.zhouf:myprj-archetype (simple project with springmvc and jetty)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 1
Define value for property 'groupId': com.zhouf
Define value for property 'artifactId': demoprj1
Define value for property 'version' 1.0-SNAPSHOT: :
Define value for property 'package' com.zhouf: :
Confirm properties configuration:
groupId: com.zhouf
artifactId: demoprj1
version: 1.0-SNAPSHOT
package: com.zhouf
 Y: :
生成项目demoprj1

7 导入Eclipse运行

将生成的项目导入到Eclipse环境中，直接部署到服务器上跑一个，测试通过，不需要修改配置，帅
如果项目是通过mvn jetty:run运行的，也可以省略中间加入Eclipse配置文件的操作

转自我的简书：https://www.jianshu.com/p/fb5c0e39692f


ZhouFeng 2019-06-24 10:55 发表评论
]]>Tomcat配置cgi运行python脚本http://www.blogjava.net/zhouf/articles/433448.htmlZhouFengZhouFengSat, 20 Oct 2018 02:34:00 GMThttp://www.blogjava.net/zhouf/articles/433448.htmlhttp://www.blogjava.net/zhouf/comments/433448.htmlhttp://www.blogjava.net/zhouf/articles/433448.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/433448.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/433448.html
1、在web工程WEB-INF目录下创建目录cgi，当然也可以是别的名字
2、修改web.xml，开启如下设置，默认情况是注释掉的
<servlet>
    <servlet-name>cgi</servlet-name>
    <servlet-class>org.apache.catalina.servlets.CGIServlet</servlet-class>
    <init-param>
        <param-name>clientinputTimeout</param-name>
        <param-value>100</param-value>
    </init-param>
    <init-param>
        <param-name>debug</param-name>
        <param-value>0</param-value>
    </init-param>
    <init-param>
        <param-name>passShellEnvironment</param-name>
        <param-value>true</param-value>
    </init-param>
    <init-param>
        <param-name>cgiPathPrefix</param-name>
        <param-value>WEB-INF/cgi</param-value>
    </init-param>
    <init-param>
        <param-name>executable</param-name>
        <param-value>D:/Anaconda3/python.exe</param-value>
    </init-param>
    <load-on-startup>5</load-on-startup>
</servlet>
注意修改python的路径
cgiPathPrefix: 与Server能够访问的脚本目录有关，与之前创建的目录相对应

3、开启cgi的mapping映射，修改web.xml，开启如下设置
<servlet-mapping>
    <servlet-name>cgi</servlet-name>
    <url-pattern>/cgi-bin/*</url-pattern>
</servlet-mapping>
访问路径可以修改为自定义字符
4、修改content.xml文件，在Context中添加privileged属性
<Context privileged="true">

5、在工程cgi目录写python文件，如hello.py
print('Content-type: text/plain\n\n')

print('Hello python')
输出text/plain说明这是一个普通文本，一定注意之后要有两个换行（小心坑啦）！！！

6、运行工程并测试
http://localhost:8080/prj/cgi-bin/hello.py

所见结果，通过这种方法可以在Tomcat环境下运行python脚本了，如果是已经用python脚本做好了服务的话，还是可以考虑通过服务调用的方式与Tomcat工程进行整合，在此记录一下


ZhouFeng 2018-10-20 10:34 发表评论
]]>网页语音播报的实现http://www.blogjava.net/zhouf/articles/432483.htmlZhouFengZhouFengTue, 25 Apr 2017 10:48:00 GMThttp://www.blogjava.net/zhouf/articles/432483.htmlhttp://www.blogjava.net/zhouf/comments/432483.htmlhttp://www.blogjava.net/zhouf/articles/432483.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/432483.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/432483.html因为需要实现在页面中进行语音提示，有点像美团那个外卖的提示音“您有新的订单，请注意查收”，于是开始搜寻方法，最后发现一个开源项目，https://github.com/wenco/speech 用来实现语音播报，上面有文档说明。先clone下来试试
按照所给的代码，运行起来没有问题，需要在页面中放入一个标签，并写入要转换为语音的内容。为了后面为了调用方便，下面进行了一些调整。
把播放按钮隐藏起来，让事件触发播放。
修改jQuery.speech.min.js，因页面引用的文件是这个，也可以单独创建一个js在页面中引入，写入以下内容
//语音内容放在页面元素中，如果没有则创建<div style="display: none" id="tts_content"></div>
function say(arg) {

    //处理页面元素
    if($("#tts_content").length == 0){
        //存在元素
        $("<div style='display: none' id='tts_content'></div>").appendTo("body");
    }

    //处理传入参数
    if(arg){
        $('#tts_content').text(arg);
    }else{
        $('#tts_content').text("您有新的消息，请注意查收");
    }
    
    //转化为语音
    $('#tts_content').speech({
        "speech": false,
        "speed": 16
    });
}
调整了播报速度，在程序中自动创建需要的标签，需要播报的内容根据参数传入，没有参数也可以播报默认的消息，经过这样简单的封装后，在调用时，就只需要调用say()方法即可，不需要在页面中放入标签，也方便放入其他事件中，然后页面就可以这样了
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>语音播报</title>
</head>
<body>
<style type="text/css">
body{background-color:#fff;padding-top:50px;}
</style>
<script src="js/jQuery/jQuery-2.1.4.min.js"></script>
<script src="js/speech/jQuery.speech.min.js"></script>

<button id="kk">说一个</button>
<script>
$("#kk").click(function() {
    say("您有新的订单，请注意查收");
    //say();
});
</script>
</body>
</html>
添加按钮只是为了演示事件触发，需要说什么内容就传入什么参数，如果不传入参数，则播报默认内容。这样的调用，甚是简单，终于完成了这样的功能，很帅，哈哈:D
致谢https://github.com/wenco/speech


ZhouFeng 2017-04-25 18:48 发表评论
]]>Tomcat+Eclipse环境下使用Jenkins2.38搭建持续集成(CI)环境http://www.blogjava.net/zhouf/articles/432234.htmlZhouFengZhouFengMon, 02 Jan 2017 03:51:00 GMThttp://www.blogjava.net/zhouf/articles/432234.htmlhttp://www.blogjava.net/zhouf/comments/432234.htmlhttp://www.blogjava.net/zhouf/articles/432234.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/432234.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/432234.html

1.下载安装Jenkins

可以在http://mirrors.jenkins-ci.org上下载安装包，也可以选择在官网（https://jenkins.io）上下载war包(http://mirrors.jenkins.io/war-stable/latest/jenkins.war)或是安装包(http://mirrors.jenkins-ci.org/windows/jenkins-2.38.zip)，写这篇文章时最新版本为2.38。如果选择安装包方式，下载后安装即可，安装完成后会自动启动浏览器向导，根据提示操作完成安装
本机下载安装包，安装到C:\Jenkins，如下配置也是基于此目录进行，下载及安装过程截图如下

选择Download Jenkins

下拉选择相应的操作系统版本，也可以直接下载war包，本文下载Windows版本的安装包，安装过程指定安装目录即可，安装完成后，会自动启动浏览器进行配置

根据页面提示，在文件中找到密码填入

选择插件，本例选择第二项，自己定义插件，打开第二项里的默认选择和推荐插件一样，如果不做修改，就相当于选择推荐插件安装

安装完成后，设置管理员账号

保存结束安装

点击开始进入Jenkins界面

2.启动Jenkins

Jenkins默认工作目录会在当前用户目录下创建.jenkins目录，也可以通过设置环境变量来修改，例如：
set JENKINS_HOME=C:\jenkins
然后重新启动jenkins，可以放在与安装目录不同的地方
进入安装目录C:\Jenkins，用命令行方式启动
java -jar jenkins.war
默认端口为8080，如果需要指定端口，可以使用如下参数指定，如指定端口为9000
java -jar jenkins.war --httpPort=9000
也可以修改目录下的jenkins.xml配置文件，将其中的httpPort修改即可
<arguments>-Xrs -Xmx256m -Dhudson.lifecycle=hudson.lifecycle.WindowsServiceLifecycle -jar "%BASE%\jenkins.war" --httpPort=8080 --webroot="%BASE%\war"</arguments>

3.部署应用到Jenkins

之前的工程是基于Tomcat+Eclipse开发的，工程不是用Maven管理的，后面就对工程进行了改造，用Ant编译，添加了build.xml文件，在Ant中需要找到Tomcat目录，为了灵活一点，在系统里添加了Tomcat的环境变量CATALINA_HOME，以及Ant环境的安装，这是对原有工程的改造，如果新的工程采用Maven方式的话，应该会没有这么麻烦，附上build.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<project basedir="." default="build" name="xi">
    <property environment="env"/>
    <property name="tomcat.home" value="${env.CATALINA_HOME}" />
    <property name="tomcat.lib" value="${env.CATALINA_HOME}/lib" />
    <property name="web.root" value="${env.CATALINA_HOME}/webapps"/>
    <property name="ant.home" value="${env.ANT_HOME}" />
    <property name="debuglevel" value="source,lines,vars"/>
    <property name="target" value="1.7"/>
    <property name="source" value="1.7"/>
    <property name="webRoot.dir" value="${basedir}/WebContent" />
    <property name="src.dir" value="${basedir}/src" />
    <property name="lib.dir" value="${webRoot.dir}/WEB-INF/lib" />  
    <property name="log.file" value="${tomcat.home}/webapps/log.info"/> 

    <tstamp> 
        <format property="build.time" pattern="yyyy-MM-dd HH:mm:ss" /> 
    </tstamp>


    <path id="prj.classpath">
        <pathelement location="build/classes"/>
        <fileset dir="${tomcat.lib}">  
            <include name="*.jar" />  
        </fileset>
        <fileset dir="${lib.dir}">  
            <include name="*.jar" />  
        </fileset>
    </path>
    <path id="tomcat.classpath">
        <fileset dir="${tomcat.lib}">  
            <include name="*.jar" />  
        </fileset>
        <fileset dir="${tomcat.home}/bin">  
            <include name="*.jar" />  
        </fileset>
    </path>

    <target name="init">
        <echo message="---------- init ----------"></echo>
        <mkdir dir="build/classes"/>
        <copy includeemptydirs="false" todir="build/classes">
            <fileset dir="src">
                <exclude name="**/*.java"/>
            </fileset>
        </copy>
    </target>
    
    <target name="clean">
        <echo message="---------- clean ----------"></echo>
        <delete dir="build/classes"/>
        <delete file="build/${ant.project.name}.war"></delete>
    </target>

    <target name="compile" depends="init">
        <echo message="${ant.project.name}: ${ant.file}"/>
        <javac debug="true" debuglevel="${debuglevel}" destdir="build/classes" includeantruntime="false"  encoding="UTF-8">
            <src path="src"/>
            <classpath refid="prj.classpath"/>
        </javac>
        <delete file="build/classes/gen-conf.xml"/>
    </target>

    <target name="build" depends="compile" description="make war">
        <war destfile="build/${ant.project.name}.war" basedir="WebContent" webxml="WebContent/WEB-INF/web.xml">
            <!-- lib dir="${lib.dir}"></lib -->
            <classes dir="${basedir}/build/classes"></classes>
        </war>
    </target>

    <target name="deploy" depends="build" description="deploy to tomcat"> 
        <echo message="----------deploy to tomcat----------"></echo>
        <delete file="${tomcat.home}/webapps/${ant.project.name}.war" /> 
        <delete dir="${tomcat.home}/webapps/${ant.project.name}" /> 
        <copy file="build/${ant.project.name}.war" todir="${tomcat.home}/webapps" /> 
    </target>

    <target name="undeploy" description="deploy to tomcat"> 
        <echo message="---------- undeploy project ----------"></echo>
        <delete file="${tomcat.home}/webapps/${ant.project.name}.war" /> 
        <delete dir="${tomcat.home}/webapps/${ant.project.name}" /> 
    </target> 

    
</project>
这样写是为了在Jenkins里调用Ant完成编译和部署的工作。
在Jenkins里创建项目，当前选择的是自由项目，写好项目名称，后续就是对项目进行配置，如果不希望保留过多的旧构建，可以设置丢弃。另外还需要获取源码的服务器，默认支持CVS和Subversion，也可以通过插件支持Git，因当前项目托管于SVN，配置如下图

后面是如何触发的配置，如下设置为每天6:30进行构建，每一个小时检查一下源码，主要是获取到代码后的动作设置

在动作设置里用Windows的批处理方式进行，原本考虑在服务器上做一个批处理，由Jenkins调用，经测试需要用绝对路径，不知是不是某个地方没配置好，后来就改用这种方式，对服务进行启动停止控制，对工程进行部署
经测试，此方式可以用，当前用来解决Tomcat+Eclipse环境下的工程自动构建问题，写在这个地方做个记录，如果有机会，尝试一下Maven，看看是不是要简单点

ZhouFeng 2017-01-02 11:51 发表评论
]]>jQuery打印插件printPagehttp://www.blogjava.net/zhouf/articles/printpage.htmlZhouFengZhouFengTue, 29 Nov 2016 03:53:00 GMThttp://www.blogjava.net/zhouf/articles/printpage.htmlhttp://www.blogjava.net/zhouf/comments/432017.htmlhttp://www.blogjava.net/zhouf/articles/printpage.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/432017.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/432017.html阅读全文

ZhouFeng 2016-11-29 11:53 发表评论
]]>JSP静态化HTML笔记http://www.blogjava.net/zhouf/articles/383790.htmlZhouFengZhouFengMon, 23 Jul 2012 11:37:00 GMThttp://www.blogjava.net/zhouf/articles/383790.htmlhttp://www.blogjava.net/zhouf/comments/383790.htmlhttp://www.blogjava.net/zhouf/articles/383790.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/383790.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/383790.html
创建一个Servlet，主要内容如下
 1 String url = "";
 2 String name = "";
 3 
 4 Charset charset = Charset.forName("UTF-8");  //设置生成文件的字符集
 5 ServletContext servletContext = getServletContext();
 6 
 7 String file_name = request.getParameter("file_name");
 8 url = "/" + file_name + ".jsp";    // 你要生成的页面动态页面来源
 9 name = servletContext.getRealPath("/")+"\\"+ file_name + ".html";
10 // 这是生成的html文件名,如index.html文件名字与源文件名相同
11 
12 RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher(url);
13 
14 final ByteArrayOutputStream outStream = new ByteArrayOutputStream();
15 
16 final ServletOutputStream stream = new ServletOutputStream() {
17     public void write(byte[] data, int offset, int length) {
18         outStream.write(data, offset, length);
19     }
20 
21     public void write(int b) throws IOException {
22         outStream.write(b);
23     }
24 };
25 
26 final PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(outStream,charset));
27 
28 HttpServletResponse rep = new HttpServletResponseWrapper(response) {
29     public ServletOutputStream getOutputStream() {
30         return stream;
31     }
32 
33     public PrintWriter getWriter() {
34         return printWriter;
35     }
36 };
37 requestDispatcher.include(request, rep);
38 printWriter.flush();
39 FileOutputStream fos = new FileOutputStream(name); // 把jsp输出的内容写到html文件中去
40 outStream.writeTo(fos);
41 fos.close();
42 out.print("<p align=center>OK</p>");
我是想把page.jsp这个文件转换成page.html，所以只传了一个参数，如果想把show.jsp?id=123转换成123.html，相信这也难不到大家，只不过得注意引用CSS或图片的路径
这是在网上那位仁兄贴出来的代码，并做了些修改，他还介绍了其它的些，其它的还没来得及学习，先把这些记录下来。
我在转换的时候，碰到中文问题，更改request和response的字符集都搞不定，还好参考了http://www.blogjava.net/zphab/articles/295631.html，把字符编码加过来了，中文才算搞定了，简单的测试通过后，放在应用里就好办了。人家写出来这么多年了，才发现，惭愧呀

以上方案参考：http://blog.csdn.net/noove_001/article/details/1953682

ZhouFeng 2012-07-23 19:37 发表评论
]]>MyBatis代码生成工具mybatis-generator的使用http://www.blogjava.net/zhouf/articles/383720.htmlZhouFengZhouFengSun, 22 Jul 2012 09:12:00 GMThttp://www.blogjava.net/zhouf/articles/383720.htmlhttp://www.blogjava.net/zhouf/comments/383720.htmlhttp://www.blogjava.net/zhouf/articles/383720.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/383720.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/383720.html首先在网上下载mybatis-generator，此处下载的是3.1.1的版本的一个zip包，下载好后解压
解压后有个doc目录和一个lib目录，doc目录提供了一个使用说明文档，lib目录是我们需要的jar文件，当然还有提供源代码和文档jar，这些可以导入MyEclipse里用
进入到lib目录中（当然也可以在别处创建一个目录，只不过在使用时要指定jar文件路径，此处为了方便点，就把文件生成在这个目录里了），创建一个配置文件，如conf.xml，此处文件名自己命名，没有命名方面的特殊要求，我是参考doc文档里的配置文件写的，如下
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
  <classPathEntry location="mysql-connector-java-3.1.13-bin.jar" />

  <context id="mysqlTables" targetRuntime="MyBatis3">

    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost/bbs"
        userId="root"
        password="1233">
    </jdbcConnection>

    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator targetPackage="test.model" targetProject="src">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>

    <sqlMapGenerator targetPackage="test.xml"  targetProject="src">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>

      
    <javaClientGenerator type="XMLMAPPER" targetPackage="test.dao"  targetProject="src">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>

    <table tableName="tb_users" >
    </table>
      
  </context>
</generatorConfiguration>
<table>标签里指定要生成的相关数据表，如果有多个表的话，需要配置多个<table>
数据库还是用之前创建好的数据库和表，并指定了要生成文件的相关表，因为要用到与数据库的连接，得加载数据库驱动，可以将mysql的驱动放在系统环境变量的classpath里，也可以在配置文件里指定路径，此处为了配置文件方便，把mysql的驱动jar包拷贝到lib目录下了，并创建一个用于存放生成文件的src文件夹
在命令窗口模式下，进入到lib目录，执行如下命令
java -jar mybatis-generator-core-1.3.1.jar -configfile conf.xml -overwrite
命令执行完成后，便可在src目录下看到生成的一些文件了，大概看了一下生成的代码，自己写的话，还是要花一点时间的，有好的工具，可真是方便呀，不过发现一个问题，生成的代码里的好多的注释，感觉注释比可用代码都多，我查了一下配置文件，找到了一个去掉生成注释的地方，把它加在了配置文件里，大概位置如下，我之前放错了地方，就没法运行
  <context id="mysqlTables" targetRuntime="MyBatis3">
  
    <commentGenerator>
      <property name="suppressAllComments" value="true" />
      <property name="suppressDate" value="true" />
    </commentGenerator>
    
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
这样改了之后，生成的代码就没有注释了，这下清爽了许多，至于<commentGenerator>标签和里面的两个属性的含义，doc文档里有详细的说明，我就不贴在这里了，如果要把生成的文件放到工程应用里，注意改下相关的路径及包名，应该就可以了。
用了一下，感觉这个东东很不错，确实省事儿不少，不过我还没有在项目中尝试，写在这里了先:)


ZhouFeng 2012-07-22 17:12 发表评论
]]>初试MyBatishttp://www.blogjava.net/zhouf/articles/383711.htmlZhouFengZhouFengSun, 22 Jul 2012 04:48:00 GMThttp://www.blogjava.net/zhouf/articles/383711.htmlhttp://www.blogjava.net/zhouf/comments/383711.htmlhttp://www.blogjava.net/zhouf/articles/383711.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/383711.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/383711.html在www.mybatis.org上可以找到下载链接，我下载的是mybatis-3.1.1这个版本，下载一个zip包，里面包含有主要的库文件mybatis-3.1.1.jar，还有一些引用的jar，一个PDF说明文档，这个说明文档提供的是E文版，可以在网上找到相应的中文版，下载完成后，就开始我的操作了。
在MyEclipse里创建了一个java工程，本来是打算在Web中使用的，没有创建Web工程，只是想试一下MyBatis这东东，java工程就可以了。
创建时引入MyBatis库和数据库驱动库，创建一个空的工程

准备好数据库，此处用MySQL做练习，创建一个bbs数据库，创建一个tb_users表，结构如下
+----------+----------+------+-----+---------+-------+
| Field    | Type     | Null | Key | Default | Extra |
+----------+----------+------+-----+---------+-------+
| userid   | int(11)  | NO   | PRI |         |       |
| username | char(20) | NO   |     |         |       |
+----------+----------+------+-----+---------+-------+

创建一个User类，与数据表对应
package com.cuit.prj.domain;

public class User {
    private int userid;
    private String userName;
    
    public User() {
        super();
    }
    public User(int userid, String userName) {
        super();
        this.userid = userid;
        this.userName = userName;
    }
    public int getUserid() {
        return userid;
    }
    public void setUserid(int userid) {
        this.userid = userid;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
}
再创建一个UserMapper接口，里面提供了对User的相关操作
package com.cuit.prj.presistence;

import com.cuit.prj.domain.User;

public interface UserMapper {
    User selectUser(int userid);
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int userid);
}
再创建一个UserMapper.xml，与UserMapper.java对应的一个配置文件，经本例测试，其中的id要和接口中的方法名一致
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cuit.prj.presistence.UserMapper">
    <select id="selectUser" parameterType="int" resultType="com.cuit.prj.domain.User">
        select *
        from tb_users where userid = #{userid}
    </select>

    <insert id="insertUser" parameterType="com.cuit.prj.domain.User">
        insert into tb_users(userid,username) values (#{userid},#{userName})
    </insert>

    <update id="updateUser" parameterType="com.cuit.prj.domain.User">
        update tb_users set username = #{userName} where userid = #{userid}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from tb_users where userid = #{userid}
    </delete>
</mapper>
在src下面创建MyBatis配置文件mybatis-conf.xml，配置文件名没有特殊规定，因为在后面的代码里需要指定文件名
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost/bbs" />
                <property name="username" value="root" />
                <property name="password" value="1233" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/cuit/prj/presistence/UserMapper.xml" />
    </mappers>
</configuration>
创建一个获取连接的SessionFactory的类
package com.cuit.prj.sessionfactory;

import java.io.IOException;
import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class SessionFactory {
    public static SqlSession getSession(){
        SqlSession session = null;
        String resource = "mybatis-conf.xml";
        try {
            Reader reader = Resources.getResourceAsReader(resource);
            SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
            session = sqlMapper.openSession();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return session;
    }
}
做好上述准备后，写一个主方法调用测试，如下
package com.cuit.prj;

import org.apache.ibatis.session.SqlSession;
import com.cuit.prj.domain.User;
import com.cuit.prj.presistence.UserMapper;
import com.cuit.prj.sessionfactory.SessionFactory;

public class AppTest {
    public static void main(String[] args) {
        System.out.println("Hello");
        SqlSession session = SessionFactory.getSession();
        try {
            UserMapper mapper = session.getMapper(UserMapper.class);

            User user = mapper.selectUser(2);
            System.out.println(user.getUserName());
        } finally {
            session.close();
        }
    }
}
在数据库中添加两条记录，并提交
+--------+----------+
| userid | username |
+--------+----------+
| 1      | user1    |
| 2      | user2    |
+--------+----------+
接下来就可以运行看看结果了。输出如下：
Hello
user2
终于跑起来了，在处理了一系列的Exception之后看到的结果，上面的测试只是做了一个读取数据的操作，如果有新增或修改数据，需要调用session.commit()操作。
大概小结一下，用了MyBatis感觉还是很不错的，把SQL语句和JAVA代码分离开，喜欢自己掌控SQL语句的人们可能会喜欢MyBatis一些，不像Hibernate那样可以完全不用写SQL语句。只是配置文件和接口写起来还是有些麻烦，还有POJO类的生成，工作量还是不小哇，网上找到一个生成工具，下次研究一下再补充上来。


ZhouFeng 2012-07-22 12:48 发表评论
]]>浮动QQ客服的实现http://www.blogjava.net/zhouf/articles/362729.htmlZhouFengZhouFengSat, 05 Nov 2011 02:01:00 GMThttp://www.blogjava.net/zhouf/articles/362729.htmlhttp://www.blogjava.net/zhouf/comments/362729.htmlhttp://www.blogjava.net/zhouf/articles/362729.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/362729.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/362729.html我是用的wp.qq.com官方网站上的提示完成了，在页面里定义一个DIV，里面的内容安排就自己确定了，我的代码如下
<!-- 在线客服部分 -->
    <div id="online_box">
        <div id="title">
            联系我们
        </div>
        <div id="qqlist">
            <p>电话:</p>
            &nbsp;&nbsp;&nbsp;(028)1234567<br>
            &nbsp;&nbsp;&nbsp;(028)1234567<br>
            <br>
            在线咨询:
            <p>
                客服1　<a target="_blank" href="http://wpa.qq.com/msgrd?v=3&uin=111111&site=qq&menu=yes">
                    <img border="0" src="http://wpa.qq.com/pa?p=2:111111:41" alt="点击这里给我发消息" title="点击这里给我发消息"></a>
            </p>
            <p>
                客服2　<a target="_blank" href="http://wpa.qq.com/msgrd?v=3&uin=222222&site=qq&menu=yes">
                    <img border="0" src="http://wpa.qq.com/pa?p=2:222222:41" alt="点击这里给我发消息" title="点击这里给我发消息"></a>
            </p>
            <p>
                客服3　<a target="_blank" href="http://wpa.qq.com/msgrd?v=3&uin=333333&site=qq&menu=yes">
                    <img border="0" src="http://wpa.qq.com/pa?p=2:333333:41" alt="点击这里给我发消息" title="点击这里给我发消息"></a>
            </p>
            
        </div>
    </div>
<!-- 在线客服部分结束 -->
那部分<a>...</a>的代码是在wp.qq.com上拷贝的，网站上还有很多的样式供选择，为了适应本来的页面样式，还得定义该层的样式，确定显示位置等，使其更规范些，我的样式定义如下
/********************在线服务部分**********************/
#online_box{
    position: absolute;
    float: right;
    left: 5px;
    top: 200px;
    z-index: 10;
    border: 1px solid #0168b7;
    width: 170px;
    background-color: white;
    text-align: left;
}
#online_box #title{
    background-color: #0168b7;
    color: white;
    font-size: 12;
    font-weight: bold;
    padding: 10px;
}
#online_box #qqlist{
    font-size: 12;
    padding: 20px;
}
#online_box #qqlist img{
    vertical-align:middle;
}
接下来就是对页面滚动的处理，实现层的浮动，我借用了jQuery来完成的，库的引入就不必再写了，下面附上写的脚本
 1 $(document).ready(function(){
 2     
 3     var bodyTop = 0;
 4     var selfHeight = $("#online_box").height();
 5     if (typeof window.pageYOffset != 'undefined') {
 6         bodyTop = window.pageYOffset;
 7     } else if (typeof document.compatMode != 'undefined' && document.compatMode != 'BackCompat') {
 8         bodyTop = document.documentElement.scrollTop;
 9     }else if (typeof document.body != 'undefined') {
10         bodyTop = document.body.scrollTop;
11     }
12     $("#online_box").css("top", bodyTop+document.body.clientHeight-selfHeight-5);    
13 });
14 
15 
16 
17 $(window).scroll(function() {
18     var bodyTop = 0;
19     var selfHeight = $("#online_box").height();
20     if (typeof window.pageYOffset != 'undefined') {
21         bodyTop = window.pageYOffset;
22     } else if (typeof document.compatMode != 'undefined' && document.compatMode != 'BackCompat') {
23         bodyTop = document.documentElement.scrollTop;
24     }else if (typeof document.body != 'undefined') {
25         bodyTop = document.body.scrollTop;
26     }
27     
28     //靠上端方式
29     //$("#online_box").css("top", 100 + bodyTop);
30 
31     //靠下端方式
32     $("#online_box").css("top", bodyTop+document.body.clientHeight-selfHeight-5);
33 });
我采用靠左下的方式显示，直接在CSS中无法确定靠下显示的页面显示高度，所以在ready()里做了一次定位，如果是按上对齐方式，这部分可以不写，直接把TOP写在CSS里就行了，下面的滚动定位也会简单些
好啦，任务完成，收工，今天周六，把前几天完成的事情记录一下先:)

ZhouFeng 2011-11-05 10:01 发表评论
]]>将数据源的连接配置改为从配置文件读取http://www.blogjava.net/zhouf/articles/299437.htmlZhouFengZhouFengThu, 22 Oct 2009 16:14:00 GMThttp://www.blogjava.net/zhouf/articles/299437.htmlhttp://www.blogjava.net/zhouf/comments/299437.htmlhttp://www.blogjava.net/zhouf/articles/299437.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/299437.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/299437.html
在此,考虑了几种方法
方法一:用Spring框架,将数据连接配置写在Spring的配置文件里,用Spring的注入方式生成对象,供程序调用
方法二:自定义一个xml文件,在数据连接写在xml中,写一个JavaBean读取xml
方法三:用Property方式定义配置配置文件,用JavaBean来读取设置
因为是一个很小的东东,为此一项而使用Spring框架,似乎有点浪费,用xml来作配置文件,自己写读取方法时也不算简单,最简单的还是第三种,也不想为这点改动用大刀,简单的就是最好的:)

首先新建一个读取配置文件的DBConfig.java(省略了包及getter,setter方法)
/**
 * 这是一个获取数据库配置的类
 * @author ZF
 */
public class DBConfig {
    private String url;
    private String driver;
    private String userName;
    private String password;

    /**
     * @param args
     */
    public static void main(String[] args) {
        DBConfig conf = new DBConfig();

    }
    
    /**
     * 在构造函数里读取配置文件
     */
    public DBConfig(){
        Properties prop= new Properties();
        try
        {
            //目录指到根目录的上级,是为了将配置文件放在WEB-INF目录下
            //如果直接放在根目录下,则需将配置文件放在classes目录下
            InputStream is = getClass().getResourceAsStream("/../dbconfig.property");
            prop.load(is);
            if(is!=null){
                is.close();
            }
        }
        catch(Exception e) {
            e.printStackTrace();
        }

        this.setDriver(prop.getProperty("Driver"));
        this.setUrl(prop.getProperty("URL"));
        this.setUserName(prop.getProperty("user"));
        this.setPassword(prop.getProperty("password"));
    }


    // getters()... and  setters()...
      
}

然后在WEB-INF目录下新建配置文件dbconfig.property
Driver=com.mysql.jdbc.Driver
URL=jdbc:mysql://localhost/tsoa
user=mysqluser
password=mysqlpassword
修改获取数据连接的代码
//获取数据库连接配置
DBConfig dbconf = new DBConfig();

//根据连接配置获取数据库连接
Class.forName(dbconf.getDriver()).newInstance();
conn= DriverManager.getConnection(dbconf.getUrl(),dbconf.getUserName(),dbconf.getPassword());
测试通过,OK,在此记录一下



ZhouFeng 2009-10-23 00:14 发表评论
]]>J2EE定时采集程序http://www.blogjava.net/zhouf/articles/263933.htmlZhouFengZhouFengWed, 08 Apr 2009 01:44:00 GMThttp://www.blogjava.net/zhouf/articles/263933.htmlhttp://www.blogjava.net/zhouf/comments/263933.htmlhttp://www.blogjava.net/zhouf/articles/263933.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/263933.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/263933.html 首先，编写一个Servlet用于启动定时器和进行任务调度，参考代码如下：
import javax.servlet.ServletContextEvent;

public class MyTimer extends javax.servlet.http.HttpServlet implements
        javax.servlet.ServletContextListener {
    // private static final long serialVersionUID = 1L;

    private java.util.Timer timer = null;

    public void contextInitialized(ServletContextEvent event) {
        timer = new java.util.Timer(true);
        System.out.println("定时器已启动");
        timer.schedule(new MyTimerTask(), 0, 24 * 60 * 60 * 1000);
        System.out.println("已经添加任务调度表");
    }

    public void contextDestroyed(ServletContextEvent event) {
        timer.cancel();
        System.out.println("定时器销毁");
    }
}
其中利用了定时器的java.util.Timer.schedule(TimerTask task, long delay, long period)方法，里面的参数依次为：任务类,延时（单位毫秒）,周期（单位毫秒）。根据我的设定，每２４小时运行一次。
然后是任务调度类：
import java.util.Calendar;
import java.util.TimerTask;

public class MyTimerTask extends TimerTask {
    private static final int C_SCHEDULE_HOUR = 22;
    private static boolean isRunning = false;

    @Override
    public void run() {
        Calendar cal = Calendar.getInstance();
        if (!isRunning) {
            if (C_SCHEDULE_HOUR < cal.get(Calendar.HOUR_OF_DAY)) {
                isRunning = true;
                System.out.println("开始执行指定任务");

                /* Your Code */

                isRunning = false;
                System.out.println("指定任务执行结束");
            }
        } else {
            System.out.println("上一次任务执行还未结束");
        }
    }
}
其中C_SCHEDULE_HOUR为执行任务的时段，根据我的要求是每天２２点后才执行我的采集程序。
最后是配置侦听器：
在web.xml中添加以下代码，当然Servlet名要换成真实的
<listener>
    <listener-class>com.test.MyTimer</listener-class>
</listener>
就这样，只需三步，一个简单的定时采集进程就搞定了

ZhouFeng 2009-04-08 09:44 发表评论
]]>eWebEditor在JBOSS下无法显示的问题http://www.blogjava.net/zhouf/articles/264392.htmlZhouFengZhouFengWed, 08 Apr 2009 01:40:00 GMThttp://www.blogjava.net/zhouf/articles/264392.htmlhttp://www.blogjava.net/zhouf/comments/264392.htmlhttp://www.blogjava.net/zhouf/articles/264392.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/264392.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/264392.html
Exception in JSP: /eWebEditor.jsp:54
经过一番折腾后又发现了如下的出错提示
java.lang.NoClassDefFoundError: org/dom4j/xpath/DefaultXPath
后来发现是dom4j.jar版本不对造成的问题,JBOSS自带的版本会出现上述的情况
解决方法如下:
将eWebEditor里自带的dom4j.jar(476K)的文件覆盖掉jboss4\lib\dom4j.jar(297K)即可,本文参考以下的材料
The error "java.lang.NoClassDefFoundError: org/dom4j/xpath/DefaultXPath" underlines important changes to the dom4j XML library. It usually happens when you try to call this library's methods in runtime. Older versions that shipped with JBoss used to include Jaxen, but for whatever reason, it is no longer included. Users must download dom4j.jar (now at version 1.6.1) and then jaxen-full.jar (FCS-1.0). Now how to resolve this problem is tricky:

   1. Put dom4j-1.3.jar in {jboss}/lib. This version is known good.
   2. Put dom4j-1.6.1.jar and jaxen-full.jar in {jboss}/server/default/lib. Remove the old dom4j JARs that may exist in that directory.

The reason the newer version cannot be used with JBoss is unknown, but it does not work. The older version is used when reading JBoss-specific config files. The newer version of dom4j kicks in when the default server is initialized. This allows development of applications using newer versions of the XML API.

http://prideafrica.blogspot.com/2006/05/javalangnoclassdeffounderror.html



ZhouFeng 2009-04-08 09:40 发表评论
]]>UrlRewrite的使用记录http://www.blogjava.net/zhouf/articles/251531.htmlZhouFengZhouFengFri, 16 Jan 2009 01:50:00 GMThttp://www.blogjava.net/zhouf/articles/251531.htmlhttp://www.blogjava.net/zhouf/comments/251531.htmlhttp://www.blogjava.net/zhouf/articles/251531.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/251531.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/251531.html 在网上下载了urlrewrite的包,我下载的是urlrewritefilter-2.6-src.zip
打开压缩包,将里面的urlrewrite-2.6.0.jar放在工程的/WEB-INF/lib/目录下
将里面的urlrewrite.xml放在工程的/WEB-INF/目录下
修改/WEB-INF/web.xml,加入过滤器
<filter>
    <filter-name>UrlRewriteFilter</filter-name>
    <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
    <init-param>
        <param-name>logLevel</param-name>
        <param-value>WARN</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>UrlRewriteFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
在urlrewrite.xml里加入规则,如:
<rule>
    <note>
        The rule means that requests to /page/pagea.html will be redirected to /pagea.jsp
    </note>
    <from>/html/([a-z]+).html</from>
    <to>/$1.jsp</to>
</rule>
此时在浏览器里访问/html/pagea.html会显示/pagea.jsp的内容,OK,搞定
如果这种地址隐藏可行,那么可以把jsp页面伪装成asp或是php页面,改写规则如下

<rule>
    <note>
        The rule means that requests to /html/pagea.html will be redirected to /pagea.jsp
    </note>
    <from>/html/([a-z]+).html</from>
    <to>/$1.jsp</to>
</rule>

<rule>
    <note>
        The rule means that requests to /asp/pagea.asp will be redirected to /pagea.jsp
    </note>
    <from>/asp/([a-z]+).asp</from>
    <to>/$1.jsp</to>
</rule>

<rule>
    <note>
        The rule means that requests to /php/pagea.php will be redirected to /pagea.jsp
    </note>
    <from>/php/([a-z]+).php</from>
    <to>/$1.jsp</to>
</rule>
此时,在浏览器里输入
/html/pagea.html
/asp/pagea.asp
/php/pagea.php
均可以访问页面pagea.jsp
几个月前我写了一篇笔记做地址伪装的,看来完全可以用这个东东代替了,上次写的那个还有一些问题没有完全解决,用urlrewrite做地址隐藏,真是感觉很专业,完美呀,初次使用,可能有些高级的功能还没有用到,不过通过这样的试验,已感觉出它的强大,这应该是一个很好的解决方案.



ZhouFeng 2009-01-16 09:50 发表评论
]]>HTML表格斑马线http://www.blogjava.net/zhouf/articles/238196.htmlZhouFengZhouFengSun, 02 Nov 2008 09:39:00 GMThttp://www.blogjava.net/zhouf/articles/238196.htmlhttp://www.blogjava.net/zhouf/comments/238196.htmlhttp://www.blogjava.net/zhouf/articles/238196.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/238196.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/238196.html/*表格间隔行变背景色*/
.row
{
 alternateColor:expression(bgColor=rowIndex%2==0?'#FFFFFF':'#EFF7FF');
 }           

 
将上面的代码加入到tr中

<table>
 <thead>
  <tr>
   <td nowrap>状态</td>

  </tr>
 </thead>
 <tbody>
  <tr class="row">
   <td nowrap>11111</td>
  </tr>
 </tbody>
</table>

ZhouFeng 2008-11-02 17:39 发表评论
]]>在TOMCAT中伪装页面后缀名http://www.blogjava.net/zhouf/articles/230810.htmlZhouFengZhouFengWed, 24 Sep 2008 01:40:00 GMThttp://www.blogjava.net/zhouf/articles/230810.htmlhttp://www.blogjava.net/zhouf/comments/230810.htmlhttp://www.blogjava.net/zhouf/articles/230810.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/230810.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/230810.html
    <servlet>
        <servlet-name>jsp</servlet-name>
        <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
        <init-param>
            <param-name>fork</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>xpoweredBy</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>3</load-on-startup>
    </servlet>
    
    
    <!-- The mapping for the JSP servlet -->
    <servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jsp</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.jspx</url-pattern>
    </servlet-mapping>
于是乎,就冒出个想法,添加一个<servlet-mapping>试试,片段如下
    <servlet-mapping>
        <servlet-name>jsp</servlet-name>
        <url-pattern>*.asp</url-pattern>
    </servlet-mapping>

我在此添加了一个ASP的映射,你还可以修改为PHP或其它的后缀,写了一个测试页面test1.asp如下

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>utf-8</title>
  </head>
  
  <body>
    <h1>This is my test page</h1>
    <h1>字符集是UTF-8</h1>
  </body>
</html>

可页面显示的情况如下

中文的显示有点问题,在相同的JSP文件里没有这种情况发生,这个问题目前还不清楚是怎么回事

于是重新建了一个文件test2.asp,然后把页面编码改成ISO-8859-1后再试

<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>ISO-8859-1</title>
  </head>
  
  <body>
    This is my JSP page. <br>
    <h1>字符集是ISO-8859-1</h1>
  </body>
</html>

页面的中文还是无法正常显示

可这时可以通过修改浏览器的页面编码来显示正确的中文,将页面编码改成 简体中文(GB2312) 后显示如下

终于OK了,而浏览器里显示的是访问一个asp的文件,可中文的字符处理仍感觉有些不完美,当页面编码是UTF-8的时候,不管怎么修改浏览器的页面编码,中文都无法正确显示,如果某兄有更好的方法解决这个问题,希望留下一点建议,谢谢

本例是在Tomcat6下做的测试



ZhouFeng 2008-09-24 09:40 发表评论
]]>从浏览器里提取语言设置信息http://www.blogjava.net/zhouf/articles/227888.htmlZhouFengZhouFengTue, 09 Sep 2008 03:06:00 GMThttp://www.blogjava.net/zhouf/articles/227888.htmlhttp://www.blogjava.net/zhouf/comments/227888.htmlhttp://www.blogjava.net/zhouf/articles/227888.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/227888.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/227888.html这两天在想一个东东,就是在I18N,在考虑如何获取客户端的语言设置,后来在JSTL的example里找到一点信息,我们可以通过ServletRequest.getLocales()方法获得一个Local对象,再从Local对象里提取信息,为了做这个测试,我还在我的浏览器设置里多加了几个语言,如下图所示

语言首选项

然后写了一个测试的JSP页面

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>Local Test</title>
  </head>
  
  <body>
    <% 
      Enumeration enum_ = request.getLocales();
      while (enum_.hasMoreElements()) {
        Locale locale = (Locale)enum_.nextElement();
        out.println("locale.getDisplayCountry():"+locale.getDisplayCountry()+"<br>");
        out.println("locale.getDisplayName():"+locale.getDisplayName()+"<br>");
        out.println("locale.getCountry():"+locale.getCountry()+"<br>");
        out.println("locale.toString():"+locale.toString()+"<br>");
        out.println("<hr>");
      }
    %>

  </body>
</html>

Local对象还有很多方法可以调用,在此我只试了几个,运行后在浏览器里得到的结果如下

locale.getDisplayCountry():中国
locale.getDisplayName():中文 (中国)
locale.getCountry():CN
locale.toString():zh_CN

--------------------------------------------------------------------------------
locale.getDisplayCountry():
locale.getDisplayName():英文
locale.getCountry():
locale.toString():en

--------------------------------------------------------------------------------
locale.getDisplayCountry():香港
locale.getDisplayName():中文 (香港)
locale.getCountry():HK
locale.toString():zh_HK

获取了这样的信息后,在JSP页面里按照浏览器语言设置来进行页面跳转应该有办法了

在看JSTL的example时,里面也有对i18N的支持,不过还没有来得及学习,也许还有更好的处理办法,就像STRUTS里的i18N处理

今天也总算搞了点东西出来,又学到一点点,Good Good Study, Day Day Up



ZhouFeng 2008-09-09 11:06 发表评论
]]>在JBOSS中使用JSTLhttp://www.blogjava.net/zhouf/articles/227827.htmlZhouFengZhouFengMon, 08 Sep 2008 15:10:00 GMThttp://www.blogjava.net/zhouf/articles/227827.htmlhttp://www.blogjava.net/zhouf/comments/227827.htmlhttp://www.blogjava.net/zhouf/articles/227827.html#Feedback0http://www.blogjava.net/zhouf/comments/commentRss/227827.htmlhttp://www.blogjava.net/zhouf/services/trackbacks/227827.html 首先在APACHE网站上可以下载JSTL(我下载的是jakarta-taglibs-standard-1.1.2.zip),可能后面的版本会有点变化
解压ZIP文件,将里面的standard.jar和jstl.jar文件放在工程中的/WEB-INF/lib目录中
在/WEB-INF目录下建一个新的文件夹tld
将zip文件里的*.tld文件解压放在/WEB-INF/tld目录中
修改/WEB-INF/web.xml文件加入如下内容


<taglib>
    <taglib-uri>http://java.sun.com/jstl/fmt</taglib-uri>
    <taglib-location>/WEB-INF/tld/fmt.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/fmt-rt</taglib-uri>
    <taglib-location>/WEB-INF/tld/fmt-1_0-rt.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/core</taglib-uri>
    <taglib-location>/WEB-INF/tld/c.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/core-rt</taglib-uri>
    <taglib-location>/WEB-INF/tld/c-1_0-rt.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/sql</taglib-uri>
    <taglib-location>/WEB-INF/tld/sql.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/sql-rt</taglib-uri>
    <taglib-location>/WEB-INF/tld/sql-1_0-rt.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/x</taglib-uri>
    <taglib-location>/WEB-INF/tld/x.tld</taglib-location>
</taglib> 

<taglib>
    <taglib-uri>http://java.sun.com/jstl/x-rt</taglib-uri>
    <taglib-location>/WEB-INF/tld/x-1_0-rt.tld</taglib-location>
</taglib>
其实可以根据使用的情况,仅将需要的tld加入到工程
布置好了.jar文件和.tld文件,以及修改了web.xml文件后,就可以在JSP页面里试试JSTL标签的魅力了
stulist.jsp
 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
 2 
 3 <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>
 4 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
 5 
 6 
 7 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 8 <html>
 9   <head>
10     <title>page</title>
11   </head>
12   
13   <sql:query var="rs" dataSource="ks2">
14       SELECT * FROM STU
15   </sql:query>
16   
17   <body>
18       <h3>学生情况<br>
19       <TABLE align="center" border="1" width="95%">
20           <tr><td>序号</td><td>学号</td><td>姓名</td></tr>
21           
22           <c:forEach var="row" items="${rs.rows}" varStatus="stat">
23               <tr><td>${stat.count}</td><td>${row.stunum}</td><td>${row.stuname}</td></tr>
24           </c:forEach>
25           
26       </TABLE>
27   </body>
28 </html>
这样的页面似乎简洁多了,看着就一个字"清爽":)

在这里还得补充一下,我是在JBOSS下做的,在<sql:query>标签里指定dataSource里碰到点问题,我的数据源是在jboss4\server\default\deploy\mysql-ds.xml里配置的,配置的数据源名字是ks,可在运行这个页面时总是提示找不到数据源,查了一些资料发现问题所在,要让JSTL能夠顺利使用JNDI的DataSource,还得在web.xml和jboss-web.xml里做修改,好让应用程序可以找到JNDI的服务,在/WEB-INF/下新建一文件jboss-web.xml,其内容如下
<?xml version="1.0" encoding="UTF-8"?>
<jboss-web>
    <resource-ref>
        <res-ref-name>ks2</res-ref-name>
        <jndi-name>java:ks</jndi-name>
    </resource-ref>
</jboss-web>
然后在web.xml里加如下面的内容
<resource-ref>
  <res-ref-name>ks2</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>
</resource-ref>
这样处理之后,在JBOSS中使用JSTL数据源的问题就解决了
刷新页面,希望看到的结果出来了,OK!
今天终于体验一了下JSTL,真是酷哇,页面比以前写的简洁多了,看来得找个时间好好学习一下这个东东了



ZhouFeng 2008-09-08 23:10 发表评论
]]>