利剑之辉的博客 - 世事如棋乾坤莫测笑尽英雄－－利剑之辉的个人站点，该站点记录了站长日常生活、学习和工作中的经历，同由于站长是个霹雳布袋戏爱好者，所以收集了很多的布袋戏剧情和资料发布在blog，供各位戏迷过瘾，同时欢迎各位同仁光临本站点

Jul 27

IT业职业道德，作为程序员是否该反思反思了

ljh , 10:11 , 利剑之辉的快乐生活 , 评论(0) , 引用(0) , 阅读(52)

这也许是一个沉重的并且不讨好的话题，因为谁都不愿意搬起石头砸自己的脚，但我们实在是幸福，总活在自以为是、感觉良好、接近天上人间的环境里，是该反思反思反省反省了，否则政策再好环境再美人才再多，也同样出不了像样的产品像样的企业像样的人物，我们习惯了在比尔盖茨的微软的产品里自娱自乐，有时候有些人有些场合下还恬不知耻地以为老子是天下第一了。

道德这个词看起来似乎过于清高与华丽，但实际上它是根基，根基不好，或歪或松或浅，都无法支撑得起高楼大厦，因此我们大多是平房或小高层，这就算了，我们还浮躁得要命，很多组织或个体只追求短期的利益，极少能静下心来创新与研发自已的东西，有时也很无奈，环境逼迫的，也许谁都不愿意那样，简单总结一下：有的时候，在利益与金钱面前，道德显得是如此地脆弱。

引言通常都是愤青一样地发唠叨，言归正传，那什么叫职业道德呢？百度百科的定义是：

“所谓职业道德，就是同人们的职业活动紧密联系的符合职业特点所要求的道德准则、道德情操与道德品质的总和，它既是对本职人员在职业活动中行为的要求，同时又是职业对社会所负的道德责任与义务。”我想，职业道德在各行各业都有其共同性，也有其特殊性，同中有异，异中有同，那么具体到IT行业，我们应该具备怎么样的职业道德才对得起社会、雇主与自已呢？

1．热爱IT行业，愿意为本行业贡献力量；

这一点看似容易，但在国内，实际上并不容易做到，我们中的很多人并不是为了兴趣而工作，为了什么？可能是生存，可能是虚荣，可能是利益，应该比较复杂。但兴趣就是最好的老师，一个人如果对自已所从事的工作都兴趣不浓，我想是很难干出什么成绩来的，兴趣是求知的向导，是学习的动力，只有对IT或编程有了浓厚的兴趣，你才会积极、主动地去完成学习与工作任务，并从中获得满足感与荣誉感。

这一点应该算是精神上的要求，不能强求，爱也好不爱也好，有时能将事情按时做好做完就已经很好了。

2．忠于企业与领导，关怀下属；

作为职业人，一生可能呆过好几家企业，与多个老板共事过，认识很多同事，但无论到哪里从事什么工作，从进入公司的那一天起就要忠于新的企业与领导，当然如果你是一个管理层，你还要尽心尽力去关怀你的下属，这是基本常识与道德，无需多言。

3．勇于承担责任，敢说敢言敢作敢为；

我们往往对于承认错误和承担责任怀有恐惧感，因为这大多会与接受惩罚相关联。所以在企业里，有时也会有一些不负责的员工，在出现问题时，他们喜欢把问题归罪于外界或者他人，想方设法寻找各式各样的理由和借口来为自己辩解。聪明的管理者会明察秋毫，不会冤枉任何的好人，也不会放过该承担负责的任何人。

没有责任感的员工不是优秀的员工，生活也好工作也好，没有谁能做得尽善尽美，但是，一个主动承认错误的员工至少是勇敢的，如何对待已经出现的问题，能看出一个人是否能够勇于承担责任。

4．充分运用上班时间，不私自聊天，上网，玩游戏等；

我经常与员工们讲上班时间的重要性，呼吁大家充分利用，实际上我们在做计划与分配工作任务时也是按上班时间与个人能力相结合的原则，但结果会千差万别，有的人提前完成工作，有的人刚好够用，有的人要加班才能完成，有的人既要加班又要别人的帮忙才能完成，这里面有能力上的差别也有自我管理能力上的差别，有的人是需要上司不停地监督与教育，他才会好好地认真工作，你一放手，他就乱来，不是聊天就是玩游戏，人或多或少都有惰性，适当的放松与娱乐是可行的，但要懂得把握与控制，企业是支付报酬给你的，因此你应该充分运用好上班的时间去做好工作，如果上班时间都充分地运用好了，那加班就不会太多，当然我们不否定有时要赶工需要加班，但正规的有道德的企业会补偿你的加班，可以毫不夸张地说，我们身边部分的加班是因为上班时的不认真造成的。

5．处理好公司利益与客户利益，公司利益与个人利益的关系；

在处理公司利益与客户利益的关系时，在保证公司信誉与形象的前提之下，员工应该以公司利益为先为主，但我们需要关注客户利益，考虑客户的价值增值问题。

关于公司利益与个人利益，二者都很重要，公司发展了，个人才会有更好地发展，公司的利益源源不断了，你的个人利益自然就会向上攀升，因此二者最终是要达到双赢的目的。而一味强调公司利益最大化，而忽视员工个人发展的企业是无法留住优秀的员工的。同样一味强调个人发展，而与公司利益存在严重分歧的员工，也将会被公司所抛弃。

6．不泄露雇主商业秘密；

这一点无需多言，但在中国，林子太大，什么鸟都有，所以这种事经常发生。

7．有始有终，善于培养接班人；

我很不喜欢一些人做一件事情或一个项目中途时离开，这是不负责任的，无论做人做事，都要有始有终，对得起自已也对得起别人。如果你是一个中高层管理者，你离开的时候最好是培养好了接班人，这对于你的公司或上司都是非常重要的，他们会很感激你，而且对于你是一种负责任的表现，这样的管理者无论到了哪里，都会受欢迎也会做得好。

8．积极创新，尽可能走自主知识产权的道路。

创新也是一种职业道德，但我们往往忽略。国内IT企业的创新能力普遍较弱，倒是比较喜欢抄袭或模仿，国外一出个什么好的产品或网站，不到几个月，国内类似的东西就如雨后春笋般不断涌现，技术含量低一些的东西我们会抄袭或模仿得很成功，但对于操作系统、数据库系统、办公软件等，我们真的不行，就算国家愿意投入几个亿，也是一样的结果，为什么？原因可以写成几本书。国内IT行业严重缺乏的东西是什么？环境与创新！

除了以上8点，当然还有很多，阿蒙不一一列举。总而言之，职业道德在任何行业都是一个关键的基础的事情，一个人行走江湖，能流芳百世的东西应该不是他的武功有多高强，而是他的人品与气度。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/harrymeng/archive/2010/05/23/5618178.aspx

Tags: 职业道德

Jul 27

古有四大名著，今有四大软件 [有图]

ljh , 10:09 , 利剑之辉的快乐生活 , 评论(0) , 引用(0) , 阅读(33)

当今中国软件业的四大软件，欢迎各位对其进行评论。

Tags: 四大软件

Jul 27

tomcat集群和负载均衡的实现（session同步）

ljh , 10:04 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(66)

(一)环境说明
(1)服务器有4台，一台安装apache,三台安装tomcat
(2)apache2.0.55、tomcat5.5.15、jk2.0.4、jdk1.5.6或jdk1.4.2
(3)ip配置,一台安装apache的ip为192.168.0.88,三台安装tomcat的服务器ip分别为192.168.0.1/2/4
(二)安装过程
(1)在三台要安装tomcat的服务器上先安装jdk
(2)配置jdk的安装路径,在环境变量path中加入jdk的bin路径,新建环境变量JAVA_HOME指向jdk的安装路径
(3)在三台要安装tomcat的服务器上分别安装tomcat,调试三个tomcat到能够正常启动
(4)tomcat的默认WEB服务端口是8080,默认的模式是单独服务,我的三个tomcat的WEB服务端口修改为7080/8888/9999
修改位置为tomcat的安装目录下的conf/server.xml
修改前的配置为
    <Connector port="8080" maxHttpHeaderSize="8192"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
修改后的配置为
    <Connector port="7080" maxHttpHeaderSize="8192"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
依次修改每个tomcat的监听端口(7080/8888/9999)

(5)分别测试每个tomcat的启动是否正常
http://192.168.0.1:7080
http://192.168.0.2:8888
http://192.168.0.4:9999
(三)负载均衡配置过程
(1)在那台要安装apache的服务器上安装apache2.0.55,我的安装路径为默认C:\Program Files\Apache Group\Apache2
(2)安装后测试apache能否正常启动，调试到能够正常启动http://192.168.0.88
(3)下载jk2.0.4后解压缩文件
(4)将解压缩后的目录中的modules目录中的mod_jk2.so文件复制到apache的安装目录下的modules目录中,我的为C:\Program Files\Apache Group\Apache2\modules
(5)修改apache的安装目录中的conf目录的配置文件httpd.conf，在文件中加LoadModule模块配置信息的最后加上一句LoadModule jk2_module modules/mod_jk2.so
(6)分别修改三个tomcat的配置文件conf/server.xml，修改内容如下
修改前

<Engine name="Catalina" defaultHost="localhost">
修改后

<Engine name="Standalone" defaultHost="localhost" jvmRoute="tomcat1">


    
将其中的jvmRoute="jvm1"分别修改为jvmRoute="tomcat1"和jvmRoute="tomcat2"和jvmRoute="tomcat3"

(7)然后重启三个tomcat，调试能够正常启动。
(8)在apache的安装目录中的conf目录下创建文件workers2.propertie，写入文件内容如下

# fine the communication channel
[channel.socket:192.168.0.1:8009]
info=Ajp13 forwarding over socket
#配置第一个服务器
tomcatId=tomcat1 #要和tomcat的配置文件server.xml中的jvmRoute="tomcat1"名称一致
debug=0
lb_factor=1 #负载平衡因子，数字越大请求被分配的几率越高

# Define the communication channel
[channel.socket:192.168.0.2:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat2
debug=0
lb_factor=1

# Define the communication channel
[channel.socket:192.168.0.4:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat3
debug=0
lb_factor=1

[status:]
info=Status worker, displays runtime information.

[uri:/jkstatus.jsp]
info=Display status information and checks the config file for changes.
group=status:

[uri:/*]
info=Map the whole webapp
debug=0
(9)在三个tomcat的安装目录中的webapps建立相同的应用,我和应用目录名为TomcatDemo,在三个应用目录中建立相同 WEB-INF目录和页面index.jsp,index.jsp的页面内容如下
<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
<html><head><title>Cluster App Test</title></head>
<body>
Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"<br>");%>
<%
out.println("<br> ID " + session.getId()+"<br>");

// 如果有新的 Session 属性设置
String dataName = request.getParameter("dataName");
if (dataName != null && dataName.length() > 0) {
String dataValue = request.getParameter("dataValue");
session.setAttribute(dataName, dataValue);
}

out.print("<b>Session 列表</b>");

Enumeration e = session.getAttributeNames();
while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value+"<br>");
         System.out.println( name + " = " + value);
   }
%>
<form action="index.jsp" method="POST">
    名称:<input type=text size=20 name="dataName">
     <br>
    值:<input type=text size=20 name="dataValue">
     <br>
    <input type=submit>
   </form>
</body>
</html>
(10)重启apache服务器和三个tomcat服务器,到此负载均衡已配置完成。测试负载均衡先测试apache,访问http://192.168.0.88/jkstatus.jsp
能否正常访问，并查询其中的内容，有三个tomcat的相关配置信息和负载说明,访问http://192.168.0.88/TomcatDemo/index.jsp看能够运行,
能运行，则已建立负载均衡。
(四)tomcat集群配置
(1)负载均衡配置的条件下配置tomcat集群
(2)分别修改三个tomcat的配置文件conf/server.xml,修改内容如下
修改前
        <!--
        <Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
                 managerClassName="org.apache.catalina.cluster.session.DeltaManager"
                 expireSessionsOnShutdown="false"
                 useDirtyFlag="true"
                 notifyListenersOnReplication="true">

<Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
                   filter=".*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;"/>

            <Deployer className="org.apache.catalina.cluster.deploy.FarmWarDeployer"
                      tempDir="/tmp/war-temp/"
                      deployDir="/tmp/war-deploy/"
                      watchDir="/tmp/war-listen/"
                      watchEnabled="false"/>

            <ClusterListener className="org.apache.catalina.cluster.session.ClusterSessionListener"/>
        </Cluster>
       
将集群配置选项的注释放开即可，如上。
(3)重启三个tomcat。到此tomcat的集群已配置完成。

(五)应用配置
对于要进行负载和集群的的tomcat目录下的webapps中的应用中的WEB-INF中的web.xml文件要添加如下一句配置
<distributable/>
配置前
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<display-name>TomcatDemo</display-name>
</web-app>
配置后
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<display-name>TomcatDemo</display-name>
<distributable/>
</web-app>

tomcat集群和负载均衡的实现（session同步）补充
因为tomcat的session同步功能需要用到组播，windows默认情况下是开通组播服务的，但是linux默认情况下并没有开通，可以通过指令打开route add -net 224.0.0.0 netmask 240.0.0.0 dev eth0，如果需要服务器启动时即开通组播需在/etc/sysconfig/static-routes文件内加入eht0 net 224.0.0.0 netmask 240.0.0.0。具体组播概念请查阅CCNP相关内容。

Jul 27

JAVA reflect 反射机制学习笔记

ljh , 09:57 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(85)

JAVA反射机制主要提供了以下功能：
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
4.在运行时调用任意一个对象的方法（*****注意：前提都是在运行时，而不是在编译时）

Java 反射相关的API简介：
位于java。lang。reflect包中
--Class类：代表一个类
--Filed类：代表类的成员变量
--Method类：代表类的方法
--Constructor类：代表类的构造方法
--Array类：提供了动态创建数组，以及访问数组的元素的静态方法。该类中的所有方法都是静态方法

1. 得到某个对象的属性

Java代码

public Object getProperty(Object owner, String fieldName) throws Exception {
Class ownerClass = owner.getClass();
Field field = ownerClass.getField(fieldName);
Object property = field.get(owner);
return property;
}

 public Object getProperty(Object owner, String fieldName) throws Exception {       Class ownerClass = owner.getClass();          Field field = ownerClass.getField(fieldName);        Object property = field.get(owner);          return property;   }

Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
2. 得到某个类的静态属性

Java代码

public Object getStaticProperty(String className, String fieldName)
throws Exception {
Class ownerClass = Class.forName(className);
Field field = ownerClass.getField(fieldName);
Object property = field.get(ownerClass);
return property;
}

   public Object getStaticProperty(String className, String fieldName)                throws Exception {      Class ownerClass = Class.forName(className);         Field field = ownerClass.getField(fieldName);           Object property = field.get(ownerClass);          return property;   }

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。
3. 执行某对象的方法

Java代码

public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(owner, args);
}

 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {        Class ownerClass = owner.getClass();           Class[] argsClass = new Class[args.length];           for (int i = 0, j = args.length; i < j; i++) {           argsClass[i] = args[i].getClass();        }          Method method = ownerClass.getMethod(methodName, argsClass);         return method.invoke(owner, args);  }

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。
4. 执行某个类的静态方法

Java代码

public Object invokeStaticMethod(String className, String methodName,
Object[] args) throws Exception {
Class ownerClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(null, args);
}

 public Object invokeStaticMethod(String className, String methodName,              Object[] args) throws Exception {        Class ownerClass = Class.forName(className);           Class[] argsClass = new Class[args.length];         for (int i = 0, j = args.length; i < j; i++) {            argsClass[i] = args[i].getClass();        }       Method method = ownerClass.getMethod(methodName, argsClass);         return method.invoke(null, args);   }

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
5. 新建实例

Java代码

public Object newInstance(String className, Object[] args) throws Exception {
Class newoneClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Constructor cons = newoneClass.getConstructor(argsClass);
return cons.newInstance(args);
}

  public Object newInstance(String className, Object[] args) throws Exception {        Class newoneClass = Class.forName(className);           Class[] argsClass = new Class[args.length];           for (int i = 0, j = args.length; i < j; i++) {            argsClass[i] = args[i].getClass();        }          Constructor cons = newoneClass.getConstructor(argsClass);        return cons.newInstance(args);      }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。
for循环：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。
6. 判断是否为某个类的实例

Java代码

public boolean isInstance(Object obj, Class cls) {
return cls.isInstance(obj);
}

  public boolean isInstance(Object obj, Class cls) {       return cls.isInstance(obj);   }

7. 得到数组中的某个元素

Java代码

public Object getByArray(Object array, int index) {
return Array.get(array,index);
}

  public Object getByArray(Object array, int index) {       return Array.get(array,index);   }

下面摘录一个应用的例子

Java代码

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestRef{
public static void main(String[] args){
TestBean test = new TestBean();
Method[] methods = test.getClass().getMethods();
test.setAbc("---");
for(int i=0;i<methods.length;i++){
if(methods[i].getName().equalsIgnoreCase("getabc")){
try {
System.out.println(methods[i].invoke(test));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
}

import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method;  public class TestRef{       public static void main(String[] args){             TestBean test = new TestBean();             Method[] methods = test.getClass().getMethods();             test.setAbc("---");             for(int i=0;i<methods.length;i++){                 if(methods[i].getName().equalsIgnoreCase("getabc")){                     try {                         System.out.println(methods[i].invoke(test));                     } catch (IllegalArgumentException e) {                         e.printStackTrace();                     } catch (IllegalAccessException e) {                         e.printStackTrace();                     } catch (InvocationTargetException e) {                         e.printStackTrace();                     }                 }             }     } }

可以扩展到action里面，如果一个action里面有多个方法，我们不用用if(){}else{}判断了，反射的确扩展性，适应性比较好呵呵

Tags: reflect , 反射

Jul 27

SSH中 struts hibernate spring 各框架各起什么作用

ljh , 09:54 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(44)

简单的说：

struts 控制用的

hibernate 操作数据库的

spring 用解耦的

详细的说：

STRUTS 在 SSH 框架中起控制的作用 , 其核心是 Controller, 即 ActionServlet, 而 ActionServlet 的核心就是 Struts-confi g.xml. 主要控制逻辑关系的处理 .

hibernate 是数据持久化层 , 是一种新的对象、关系的映射工具 , 提供了从 Java 类到数据表的映射，也提供了数据查询和恢复等机制 , 大大减少数据访问的复杂度。把对数据库的直接操作 , 转换为对持久对象的操作 .

SPRING 是一个轻量级的控制反转 (IoC) 和面向切面 (AOP) 的容器框架 , 面向接口的编程 , 由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓 “ 控制反转 ” 的概念所在：（依赖）控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中
起到的主要作用是解耦

Struts 、 spring 、 Hibernate 在各层的作用

1 ） struts 负责 web 层 .

ActionFormBean 接收网页中表单提交的数据，然后通过 Action 进行处理，再 Forward 到对应的网页。

在 struts-config.xml 中定义 <action-mapping>, ActionServlet 会加载。

2 ） spring 负责业务层管理，即 Service （或 Manager).

1 ． service 为 action 提供统计的调用接口，封装持久层的 DAO.

2 ．可以写一些自己的业务方法。

3 ．统一的 javabean 管理方法

4 ．声明式事务管理

5. 集成 Hiberante

3 ） Hiberante ，负责持久化层，完成数据库的 crud 操作

hibernate 为持久层，提供 OR/Mapping 。

它有一组 .hbm.xml 文件和 POJO, 是跟数据库中的表相对应的。然后定义 DAO ，这些是跟数据库打交道的类，它们会使用 PO 。

在 struts+spring+hibernate 的系统中，

对象的调用流程是： jsp-> Action － > Service ->DAO ->Hibernate 。

数据的流向是 ActionFormBean 接受用户的数据， Action 将数据从 ActionFromBean 中取出，封装成 VO 或 PO,

再调用业务层的 Bean 类，完成各种业务处理后再 forward 。而业务层 Bean 收到这个 PO 对象之后，会调用 DAO 接口方法，进行持久化操作。

分页： 7/60

2 3 4 5 6 7 8 9 10 11

[ 显示模式：摘要 | 列表 ]

IT业职业道德，作为程序员是否该反思反思了

古有四大名著，今有四大软件 [有图]

tomcat集群和负载均衡的实现（session同步）

JAVA reflect 反射机制学习笔记

SSH中 struts hibernate spring 各框架各起什么作用

公告

分类

日历

统计

最新日志

最新评论

链接

归档

其他

< 2010 > < 9 >
日	一	二	三	四	五	六
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30