星星的金币的博客 欢迎你来到我在javaeye的博客，本博客数据来自我自主开发的多用户博客SGblog，由javaeye RSS同步导入的。若您有什么建议和问题，请到我的网站上访问。 http://sgwood.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 77go负载 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/177656  发表时间: 2008年03月29日

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

其中是开许多resin ,例如：
resin77go-fuzhai.bat中开了四个httpd:
start E:\webtools\resin\httpd.exe -conf E:\webtools\resin\conf\resin77go-fuzhai.conf -server a
start E:\webtools\resin\httpd.exe -conf E:\webtools\resin\conf\resin77go-fuzhai.conf -server b
start E:\webtools\resin\httpd.exe -conf E:\webtools\resin\conf\resin77go-fuzhai.conf -server c
start E:\webtools\resin\httpd.exe -conf E:\webtools\resin\conf\resin77go-fuzhai.conf -server d
在resin77go-fuzhai.conf中
  <cluster>
      <srun server-id="a" host="127.0.0.1" port="6801"/>
      <srun server-id="b" host="127.0.0.1" port="6802"/>
      <srun server-id="c" host="127.0.0.1" port="6803"/>
      <srun server-id="d" host="127.0.0.1" port="6804"/>
    </cluster>

    <host id='www.77go.cn'>
      <document-directory>D:/77go</document-directory>

      <!-- configures the root web-app -->
      <web-app id='/'>
        <!-- adds xsl to the search path -->
        <class-loader>
          <compiling-loader path='WEB-INF/classes'/>
          <library-loader path='WEB-INF/lib'/>
        </class-loader>
      </web-app>
    </host>

LoadModule caucho_module "E:/webtools/resin/win32/apache-2.0/mod_caucho.dll"
<IfModule mod_caucho.c>
#   ResinConfigServer localhost 6811
#   CauchoStatus yes
# </IfModule>
# <IfModule mod_caucho.c>
#   ResinConfigServer localhost 6812
#   CauchoStatus yes
# </IfModule>
# <IfModule mod_caucho.c>
#   ResinConfigServer localhost 6813
#   CauchoStatus yes
# </IfModule>
# <IfModule mod_caucho.c>
#   ResinConfigServer localhost 6814
#   CauchoStatus yes
# </IfModule>

#<VirtualHost *:80>
#    DocumentRoot D:/77go
#    ServerName www.77go.cn
#    DirectoryIndex index.jsp index.htm index.html
#    Options FollowSymLinks
#    ErrorLog D:/77go/logs/www.77go.cn-error_log
#    CustomLog D:/77go/logs/access_www.77go.cn.log common
#    CustomLog "|bin/cronolog.exe E:/77go_log/%y/%m/%d/access_www.77go.cn.log" combined env=!img-request
#    ErrorLog  "|bin/cronolog.exe E:/77go_log/%y/%m/%d/error_www.77go.cn.log"
#</VirtualHost>

下面是网上的一篇相关配置：
配置resin负载均衡

下面就简单列出如何配置load balance，以resin 3为例：



配置apache：

假设我开4个cluster，ip分别是10.10.22.1、10.10.22.2、10.10.22.3、10.10.22.4。网卡设置好。在apache的配置文件httpd.conf的最后有3句话：

LoadModule caucho_module /usr/local/apache-mysql/libexec/mod_caucho.so
ResinConfigServer localhost 6802
CauchoStatus yes

只需将第二句改成：

ResinConfigServer 10.10.22.1 6802
ResinConfigServer 10.10.22.2 6802
ResinConfigServer 10.10.22.3 6802
ResinConfigServer 10.10.22.4 6802

resin的配置：

<!-- <http port='80'/> -->

<cluster>
<srun server-id="a" host="10.10.22.1" port="6802" index="1"/> <srun server-id="b" host="10.10.22.2" port="6802" index="2"/> <srun server-id="c" host="10.10.22.3" port="6802" index="3"/> <srun server-id="d" host="10.10.22.4" port="6802" index="4"/> </cluster>

其他根据自己需求配置！

6. 启动resin和apache：由于使用负载均衡技术，因此启动也不单单是起一个http.sh了。可以写一个脚本：

#!/bin/bash
/usr/local/apache/bin/apachectl start
/usr/local/resin/bin/httpd.sh -pid /usr/local/resin/srun1.pid -server a start
/usr/local/resin/bin/httpd.sh -pid /usr/local/resin/srun2.pid -server b start
/usr/local/resin/bin/httpd.sh -pid /usr/local/resin/srun3.pid -server c start
/usr/local/resin/bin/httpd.sh -pid /usr/local/resin/srun4.pid -server d start

对于resin的负载均衡使用上启动的进程数，我认为还是要根据自己的机器实际情况来考虑的。少了达不到效果，多了会机器系统也是一个负载。个人认为，4个可以作为一个默认的选择来考虑。

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sat, 29 Mar 2008 21:09:26 +0800 http://sgwood.javaeye.com/blog/177656 http://sgwood.javaeye.com/blog/177656 C3P0连接池详细配置 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/177132  发表时间: 2008年03月28日

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

转载至:http://jacreater.spaces.live.com/blog/cns!BE44984C5949B55B!120.entry

<c3p0-config>
  <default-config>
 <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
 <property name="acquireIncrement">3</property>
 
 <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
 <property name="acquireRetryAttempts">30</property>
 
 <!--两次连接中间隔时间，单位毫秒。Default: 1000 -->
 <property name="acquireRetryDelay">1000</property>
 
 <!--连接关闭时默认将所有未提交的操作回滚。Default: false -->
 <property name="autoCommitOnClose">false</property>
 
 <!--c3p0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么
  属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试
  使用。Default: null-->
 <property name="automaticTestTable">Test</property>

 <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
  保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
  获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
 <property name="breakAfterAcquireFailure">false</property>
 <!--当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后将抛出
  SQLException,如设为0则无限期等待。单位毫秒。Default: 0 -->
 <property name="checkoutTimeout">100</property>
 <!--通过实现ConnectionTester或QueryConnectionTester的类来测试连接。类名需制定全路径。
  Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester-->
 <property name="connectionTesterClassName"></property>
 <!--指定c3p0 libraries的路径，如果（通常都是这样）在本地即可获得那么无需设置，默认null即可
  Default: null-->
 <property name="factoryClassLocation">null</property>
 <!--Strongly disrecommended. Setting this to true may lead to subtle and bizarre bugs.
  （文档原文）作者强烈建议不使用的一个属性-->
 <property name="forceIgnoreUnresolvedTransactions">false</property>
 <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
 <property name="idleConnectionTestPeriod">60</property>
 <!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
 <property name="initialPoolSize">3</property>
 
 <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
 <property name="maxIdleTime">60</property>
 
 <!--连接池中保留的最大连接数。Default: 15 -->
 <property name="maxPoolSize">15</property>
 
 <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
  属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
  如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0-->
 <property name="maxStatements">100</property>
 
 <!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0  -->
 <property name="maxStatementsPerConnection"></property>
 <!--c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能
  通过多线程实现多个操作同时被执行。Default: 3-->
 <property name="numHelperThreads">3</property>
 <!--当用户调用getConnection()时使root用户成为去获取连接的用户。主要用于连接池连接非c3p0
  的数据源时。Default: null-->
 <property name="overrideDefaultUser">root</property>
 
 <!--与overrideDefaultUser参数对应使用的一个参数。Default: null-->
 <property name="overrideDefaultPassword">password</property>
 <!--密码。Default: null-->
 <property name="password"></property>
 <!--定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。注意：
  测试的表必须在初始数据源的时候就存在。Default: null-->
 <property name="preferredTestQuery">select id from test where id=1</property>
 <!--用户修改系统配置参数执行前最多等待300秒。Default: 300 -->
 <property name="propertyCycle">300</property>
 
 <!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
  时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
  等方法来提升连接测试的性能。Default: false -->
 <property name="testConnectionOnCheckout">false</property>
 
 <!--如果设为true那么在取得连接的同时将校验连接的有效性。Default: false -->
 <property name="testConnectionOnCheckin">true</property>
 <!--用户名。Default: null-->
 <property name="user">root</property>
 <!--早期的c3p0版本对JDBC接口采用动态反射代理。在早期版本用途广泛的情况下这个参数
  允许用户恢复到动态反射代理以解决不稳定的故障。最新的非反射代理更快并且已经开始
  广泛的被使用，所以这个参数未必有用。现在原先的动态反射与新的非反射代理同时受到
  支持，但今后可能的版本可能不支持动态反射代理。Default: false-->
 <property name="usesTraditionalReflectiveProxies">false</property>

    <property name="automaticTestTable">con_test</property>
    <property name="checkoutTimeout">30000</property>
    <property name="idleConnectionTestPeriod">30</property>
    <property name="initialPoolSize">10</property>
    <property name="maxIdleTime">30</property>
    <property name="maxPoolSize">25</property>
    <property name="minPoolSize">10</property>
    <property name="maxStatements">0</property>
    <user-overrides user="swaldman">
    </user-overrides>
</default-config>
  <named-config name="dumbTestConfig">
    <property name="maxStatements">200</property>
    <user-overrides user="poop">
      <property name="maxStatements">300</property>
    </user-overrides>
   </named-config>
</c3p0-config>


已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 28 Mar 2008 10:06:42 +0800 http://sgwood.javaeye.com/blog/177132 http://sgwood.javaeye.com/blog/177132 Eclipse中设置在创建新类时自动生成注释(转) sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/177130  发表时间: 2008年03月28日

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

Eclipse中设置在创建新类时自动生成注释


windows-->preference
Java-->Code Style-->Code Templates
code-->new Java files
编辑它

${filecomment}
${package_declaration}
/**
* @author 作者 E-mail:
* @version 创建时间：${date} ${time}
* 类说明
*/
${typecomment}
${type_declaration}

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 28 Mar 2008 10:03:54 +0800 http://sgwood.javaeye.com/blog/177130 http://sgwood.javaeye.com/blog/177130 extjs demo sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/175645  发表时间: 2008年03月25日

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

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
<title>ExtJS</title>
<link rel="stylesheet" type="text/css" href="ext-2.0/resources/css/ext-all.css" />  
<script type="text/javascript" src="ext-2.0/adapter/ext/ext-base.js"></script> 
<script type="text/javascript" src="ext-2.0/ext-all.js"></script>
<script>
function showUrl(value)

{

return "<a href=http://"+value+">"+value+"</a>";

}

Ext.onReady(function(){

/**
var data=[ [1, 'EasyJWeb', 'EasyJF','www.easyjf.com'],

[2, 'jfox', 'huihoo','www.huihoo.org'],

[3, 'jdon', 'jdon','www.jdon.com'],

[4, 'springside', 'springside','www.springside.org.cn'] ];

var store=new Ext.data.SimpleStore({data:data,fields:["id","name","organization","homepage"]});*/
var data=[{id:1,

name:'EasyJWeb',

organization:'EasyJF',

homepage:'www.easyjf.com'},

{id:2,

name:'jfox',

organization:'huihoo',

homepage:'www.huihoo.org'},

{id:3,

name:'jdon',

organization:'jdon',

homepage:'www.jdon.com'},

{id:4,

name:'springside',

organization: 'springside',

homepage:'www.springside.org.cn'}

];
var store=new Ext.data.JsonStore({data:data,fields:["id","name","organization","homepage"]});

var colM=new Ext.grid.ColumnModel([{header:"项目名称",dataIndex:"name",sortable:true},

{header:"开发团队",dataIndex:"organization",sortable:true},

{header:"网址",dataIndex:"homepage",renderer:showUrl}]);


var grid = new Ext.grid.GridPanel({

renderTo:"hello",

title:"中国Java开源产品及团队",

height:150,

width:600,

cm:colM,


store:store,

autoExpandColumn:2

});

});
</script>
</head>
<body>
<div id="hello">
</body>
</html>

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Tue, 25 Mar 2008 09:27:34 +0800 http://sgwood.javaeye.com/blog/175645 http://sgwood.javaeye.com/blog/175645 struts2 code-behind sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/166331  发表时间: 2008年03月01日

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

code-behind在struts2里有两种表现形式：
1.Default mappings (默认映射)：其实就是访问那些没有配置过Action的JSP页面，也能像访问Action那样访问。
比如说在项目${root}/leo/a.jsp 有这么一个a.jsp.
我可以在地址栏里输入：http://localhost:8080/项目名称/leo/a.action 来访问这个 a.jsp
效果与 http://localhost:8080/项目名称/leo/a.jsp是一样的。类似于咱们在welcome-file 那里定义的index，
这就是默认映射。

2.Default results (默认结果)：其实就是无须显示的在struts-*.xml里配置那些返回 jsp, vm. ftl视图的Action。
比如说，我有一个以下配置文件， 没有result.
<package name="code" extends="struts-default" namespace="/code">
<action name="leo" class="code.LeoAction" />
</package>

Action文件是这样的：
package code;

import com.opensymphony.xwork2.ActionSupport;

public class LeoAction extends ActionSupport {

private static final long serialVersionUID = 1L;

private String flag = "";

public String getFlag() {
return flag;
}

public void setFlag(String flag) {
this.flag = flag;
}

public String execute() {
if (flag == null || flag.equals("")) {
this.addActionMessage("input message");
return INPUT;
} else if (flag != null && flag.equals("error")) {
this.addActionError("error happen");
return ERROR;
} else {
this.addActionMessage("I am leo");
return SUCCESS;
}
}

}

故意设置了一个 flag 来查看结果。 通过，http://localhost:8080/项目名称/leo/leo.action?flag=测试值
你会发现，
INPUT   对应 http://localhost:8080/项目名称/leo/leo-input.jsp
ERROR   对应 http://localhost:8080/项目名称/leo/leo-error.jsp
SUCCESS 对应 http://localhost:8080/项目名称/leo/leo-success.jsp

这就是默认结果的意思。

下面是codebehind的path示例:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<constant name="struts.devMode" value="false" />
<constant name="struts.i18n.encoding" value="UTF-8" />
<constant name="struts.action.extension" value="html" />
<constant name="struts.objectFactory" value="spring" />
<constant name="struts.custom.i18n.resources"
value="ApplicationResources,errors" />
<constant name="struts.multipart.maxSize" value="2097152" />
<constant name="struts.ui.theme" value="css_xhtml" />
<constant name="struts.codebehind.pathPrefix"
value="/WEB-INF/pages/" />

<!-- Include Struts defaults -->
<include file="struts-default.xml" />

<!-- Configuration for the default package. -->
<package name="default" extends="struts-default">
<default-interceptor-ref name="defaultStack" />
<!-- DashBoard-->
<action name="dashBoard" method="showDashBoard"
class="com.flips.action.DashBoard">
<result name="success">dashBoard.jsp</result>
<interceptor-ref name="basicStack"/>
</action>

<action name="showRule" method="showRule"
class="com.flips.action.RuleImpl">
<result name="success">ruleList.jsp</result>
<interceptor-ref name="basicStack"/>

</action>

</package>
</struts>

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sat, 01 Mar 2008 09:39:51 +0800 http://sgwood.javaeye.com/blog/166331 http://sgwood.javaeye.com/blog/166331 a href=#与 a href=javascript:void(0) 的区别 打开新窗口链接的几种 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/166138  发表时间: 2008年02月29日

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

＃包含了一个位置信息

默认的锚点是＃top 也就是网页的上端

而javascript:void(0)  仅仅表示一个死链接

这就是为什么有的时候页面很长浏览链接明明是＃可是

跳动到了页首

而javascript:void(0) 则不是如此

所以调用脚本的时候最好用void(0)

或者<input onclick>

<div onclick>等

打开新窗口链接的几种办法

1.window.open('url')

2.用自定义函数

        <script>
        function openWin(tag,obj)
        {
            obj.target="_blank";
            obj.href = "Web/Substation/Substation.aspx?stationno="+tag;
            obj.click();
        }
        </script>

 

<a  href="javascript:void(0)" onclick="openWin(3,this)">www.webkkk.net(绝对领域)</a>


window.location.href=""



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 29 Feb 2008 14:47:02 +0800 http://sgwood.javaeye.com/blog/166138 http://sgwood.javaeye.com/blog/166138 从LiveJournal后台发展看大规模网站性能优化方法 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/165945  发表时间: 2008年02月28日

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

一、LiveJournal发展历程

LiveJournal是99年始于校园中的项目，几个人出于爱好做了这样一个应用，以实现以下功能：
  • 博客，论坛
  • 社会性网络，找到朋友
  • 聚合，把朋友的文章聚合在一起
LiveJournal采用了大量的开源软件，甚至它本身也是一个开源软件。

在上线后，LiveJournal实现了非常快速的增长：

  • 2004年4月份：280万注册用户。
  • 2005年4月份：680万注册用户。
  • 2005年8月份：790万注册用户。
  • 达到了每秒钟上千次的页面请求及处理。
  • 使用了大量MySQL服务器。
  • 使用了大量通用组件。

二、LiveJournal架构现状概况

livejournal_backend.png

三、从LiveJournal发展中学习

 

LiveJournal从1台服务器发展到100台服务器，这其中经历了无数的伤痛，但同时也摸索出了解决这些问题的方法，通过对LiveJournal的学习，可以让我们避免LJ曾经犯过的错误，并且从一开始就对系统进行良好的设计，以避免后期的痛苦。

下面我们一步一步看LJ发展的脚步。

1、一台服务器

一台别人捐助的服务器，LJ最初就跑在上面，就像Google开始时候用的破服务器一样，值得我们尊敬。这个阶段，LJ的人以惊人的速度熟悉的Unix的操作管理，服务器性能出现过问题，不过还好，可以通过一些小修小改应付过去。在这个阶段里LJ把CGI升级到了FastCGI。

最终问题出现了，网站越来越慢，已经无法通过优过化来解决的地步，需要更多的服务器，这时LJ开始提供付费服务，可能是想通过这些钱来购买新的服务器，以解决当时的困境。
毫无疑问，当时LJ存在巨大的单点问题，所有的东西都在那台服务器的铁皮盒子里装着。

LJ-backend-7.png

2、两台服务器

用付费服务赚来的钱LJ买了两台服务器：一台叫做Kenny的Dell 6U机器用于提供Web服务，一台叫做Cartman的Dell 6U服务器用于提供数据库服务。

LJ-backend-8.png

LJ有了更大的磁盘，更多的计算资源。但同时网络结构还是非常简单，每台机器两块网卡，Cartman通过内网为Kenny提供MySQL数据库服务。

暂时解决了负载的问题，新的问题又出现了：

  • 原来的一个单点变成了两个单点。
  • 没有冷备份或热备份。
  • 网站速度慢的问题又开始出现了，没办法，增长太快了。
  • Web服务器上CPU达到上限，需要更多的Web服务器。

3、四台服务器

又买了两台，Kyle和Stan，这次都是1U的，都用于提供Web服务。目前LJ一共有3台Web服务器和一台数据库服务器。这时需要在3台Web服务器上进行负载均横。

LJ-backend-9.png

LJ把Kenny用于外部的网关，使用mod_backhand进行负载均横。

然后问题又出现了：

  • 单点故障。数据库和用于做网关的Web服务器都是单点，一旦任何一台机器出现问题将导致所有服务不可用。虽然用于做网关的Web服务器可以通过保持心跳同步迅速切换，但还是无法解决数据库的单点，LJ当时也没做这个。
  • 网站又变慢了，这次是因为IO和数据库的问题，问题是怎么往应用里面添加数据库呢？

4、五台服务器

又买了一台数据库服务器。在两台数据库服务器上使用了数据库同步(Mysql支持的Master-Slave模式)，写操作全部针对主数据库（通过Binlog，主服务器上的写操作可以迅速同步到从服务器上），读操作在两个数据库上同时进行(也算是负载均横的一种吧)。

LJ-backend-10.png

实现同步时要注意几个事项：

  • 读操作数据库选择算法处理，要选一个当前负载轻一点的数据库。
  • 在从数据库服务器上只能进行读操作
  • 准备好应对同步过程中的延迟，处理不好可能会导致数据库同步的中断。只需要对写操作进行判断即可，读操作不存在同步问题。

5、更多服务器

有钱了，当然要多买些服务器。部署后快了没多久，又开始慢了。这次有更多的Web服务器，更多的数据库服务器，存在 IO与CPU争用。于是采用了BIG-IP作为负载均衡解决方案。

LJ-backend-11.png

6、现在我们在哪里：

LJ-backend-1.png

现在服务器基本上够了，但性能还是有问题，原因出在架构上。

数据库的架构是最大的问题。由于增加的数据库都是以Slave模式添加到应用内，这样唯一的好处就是将读操作分布到了多台机器，但这样带来的后果就是写操作被大量分发，每台机器都要执行，服务器越多，浪费就越大，随着写操作的增加，用于服务读操作的资源越来越少。

LJ-backend-2.png

由一台分布到两台

LJ-backend-3.png

最终效果

现在我们发现，我们并不需要把这些数据在如此多的服务器上都保留一份。服务器上已经做了RAID，数据库也进行了备份，这么多的备份完全是对资源的浪费，属于冗余极端过度。那为什么不把数据分布存储呢？

问题发现了，开始考虑如何解决。现在要做的就是把不同用户的数据分布到不同的服务器上进行存储，以实现数据的分布式存储，让每台机器只为相对固定的用户服务，以实现平行的架构和良好的可扩展性。

为了实现用户分组，我们需要为每一个用户分配一个组标记，用于标记此用户的数据存放在哪一组数据库服务器中。每组数据库由一个master及几个slave组成，并且slave的数量在2-3台，以实现系统资源的最合理分配，既保证数据读操作分布，又避免数据过度冗余以及同步操作对系统资源的过度消耗。

LJ-backend-4.png

由一台（一组）中心服务器提供用户分组控制。所有用户的分组信息都存储在这台机器上，所有针对用户的操作需要先查询这台机器得到用户的组号，然后再到相应的数据库组中获取数据。

这样的用户架构与目前LJ的架构已经很相像了。

在具体的实现时需要注意几个问题：

  • 在数据库组内不要使用自增ID，以便于以后在数据库组之间迁移用户，以实现更合理的I/O，磁盘空间及负载分布。
  • 将userid，postid存储在全局服务器上，可以使用自增，数据库组中的相应值必须以全局服务器上的值为准。全局服务器上使用事务型数据库InnoDB。
  • 在数据库组之间迁移用户时要万分小心，当迁移时用户不能有写操作。

7、现在我们在哪里

LJ-backend-5.png

问题：

  • 一个全局主服务器，挂掉的话所有用户注册及写操作就挂掉。
  • 每个数据库组一个主服务器，挂掉的话这组用户的写操作就挂掉。
  • 数据库组从服务器挂掉的话会导致其它服务器负载过大。

对于Master-Slave模式的单点问题，LJ采取了Master-Master模式来解决。所谓Master-Master实际上是人工实现的，并不是由MySQL直接提供的，实际上也就是两台机器同时是Master，也同时是Slave，互相同步。

Master-Master实现时需要注意：

  • 一个Master出错后恢复同步，最好由服务器自动完成。
  • 数字分配，由于同时在两台机器上写，有些ID可能会冲突。

解决方案：

  • 奇偶数分配ID，一台机器上写奇数，一台机器上写偶数
  • 通过全局服务器进行分配(LJ采用的做法)。

 

Master-Master模式还有一种用法，这种方法与前一种相比，仍然保持两台机器的同步，但只有一台机器提供服务（读和写），在每天晚上的时候进行轮换，或者出现问题的时候进行切换。

8、现在我们在哪里

LJ-backend-6.png

现在插播一条广告，MyISAM VS InnoDB。

使用InnoDB：

  • 支持事务
  • 需要做更多的配置，不过值得，可以更安全的存储数据，以及得到更快的速度。

使用MyISAM：

  • 记录日志（LJ用它来记网络访问日志）
  • 存储只读静态数据，足够快。
  • 并发性很差，无法同时读写数据（添加数据可以）
  • MySQL非正常关闭或死机时会导致索引错误，需要使用myisamchk修复，而且当访问量大时出现非常频繁。

9、缓存

去年我写过一篇文章介绍memcached，它就是由LJ的团队开发的一款缓存工具，以key-value的方式将数据存储到分布的内存中。LJ缓存的数据：

  • 12台独立服务器（不是捐赠的）
  • 28个实例
  • 30GB总容量
  • 90-93%的命中率（用过squid的人可能知道，squid内存加磁盘的命中率大概在70-80%）

如何建立缓存策略？

想缓存所有的东西？那是不可能的，我们只需要缓存已经或者可能导致系统瓶颈的地方，最大程度的提交系统运行效率。通过对MySQL的日志的分析我们可以找到缓存的对象。

缓存的缺点？

  • 没有完美的事物，缓存也有缺点：
  • 增大开发量，需要针对缓存处理编写特殊的代码。
  • 管理难度增加，需要更多人参与系统维护。
  • 当然大内存也需要钱。

10、Web访问负载均衡

在数据包级别使用BIG-IP，但BIG-IP并不知道我们内部的处理机制，无法判断由哪台服务器对这些请求进行处理。反向代理并不能很好的起到作用，不是已经够快了，就是达不到我们想要的效果。

所以，LJ又开发了Perlbal。特点：

  • 快，小，可管理的http web 服务器/代理
  • 可以在内部进行转发
  • 使用Perl开发
  • 单线程，异步，基于事件，使用epoll , kqueue
  • 支持Console管理与http远程管理，支持动态配置加载
  • 多种模式：web服务器，反向代理，插件
  • 支持插件：GIF/PNG互换？

11、MogileFS

LJ使用开源的MogileFS作为分布式文件存储系统。MogileFS使用非常简单，它的主要设计思想是：

  • 文件属于类（类是最小的复制单位）
  • 跟踪文件存储位置
  • 在不同主机上存储
  • 使用MySQL集群统一存储分布信息
  • 大容易廉价磁盘

到目前为止就这么多了，更多文档可以在http://www.danga.com/words/找到。Danga.com和LiveJournal.com的同学们拿这个文档参加了两次MySQL Con，两次OS Con，以及众多的其它会议，无私的把他们的经验分享出来，值得我们学习。在web2.0时代快速开发得到大家越来越多的重视，但良好的设计仍是每一个应用的基础，希望web2.0们在成长为Top500网站的路上，不要因为架构阻碍了网站的发展。

参考资料：http://www.danga.com/words/2005_oscon/oscon-2005.pdf

 

转:http://www.example.net.cn/archives/2006/03/olivejournaloio.html



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Thu, 28 Feb 2008 19:23:27 +0800 http://sgwood.javaeye.com/blog/165945 http://sgwood.javaeye.com/blog/165945 设置文本域的背景图<textarea name="textarea" cols="35" rows= sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/165087  发表时间: 2008年02月26日

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

<textarea name="textarea" cols="35" rows="15" style="background-attachment: fixed;background-image: url(./bg.jpg)"></textarea>
注: fixed可以固定背景图，如不需要可不用。
效果图如下：
 



已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Tue, 26 Feb 2008 13:05:46 +0800 http://sgwood.javaeye.com/blog/165087 http://sgwood.javaeye.com/blog/165087 同行一边居左 一边居右 div sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/165086  发表时间: 2008年02月26日

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

原代码 - 显示为 内容A靠右
引用:
<div class="main" style="font-size: 12px; text-align: right; font-weight:bold;">内容A</div>
想把它增加右边一个内容 - 显示为 内容A靠左,内容B靠右
引用:
<table cellspacing="0" cellpadding="0" border="0" width="{TABLEWIDTH}" align="center" style="table-layout: fixed">
<tr><td class="nav" width="50%" align="left" nowrap>内容A</td>
<td align="right" width="50%">内容B</td>
</tr></table><br></div>
第一个代码是DIV,而第2个代码是table .
怎么将第一个效果,用DIV表达出来呢?
回答:
<div style="float:left;">第一个层</div><div style="float:right;">表格</div>

已有 1 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Tue, 26 Feb 2008 13:01:53 +0800 http://sgwood.javaeye.com/blog/165086 http://sgwood.javaeye.com/blog/165086 orcale使用记录 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/164551  发表时间: 2008年02月24日

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

创建表空间sgwood:
create tablespace sgwood datafile 'H:\oracle\product\10.2.0\oradata\orcl\sgwood.dbf' size 200m autoextend on next 10m maxsize unlimited;
建表admin_emp:
create table admin_emp (
empno NUMBER(5) PRIMARY KEY,
ename VARCHAR(15) NOT NULL,
ssn NUMBER(9) ,
job VARCHAR2(10),
mgr NUMBER(5),
hiredate DATE DEFAULT (sysdate),
sal NUMBER(7,2),
comm NUMBER(7,2),
deptno NUMBER(3) NOT NULL
)
alter table system.admin_emp add
(location varchar2(80),
tel varchar2(10));

alter table admin_emp
rename column ssn to ssno;
alter table admin_emp
set unused(comm);
SQL> select * from all_unused_col_tabs;

OWNER                          TABLE_NAME                          COUNT
------------------------------ ------------------------------ ----------
SYSTEM                         ADMIN_EMP                               1
//改变表存储
alter table system.admin_emp move
storage (initial 20K
next 40K
maxextents 20
pctincrease 0);

tablespace sgwood
STORAGE (INITIAL 50K);
建序列emp_sequence：
create sequence emp_sequence
increment by 1
start with 1
nomaxvalue
nocycle
cache 10;
alter sequence emp_sequence
increment by 10
maxvalue 1000
cycle
cache 20;
insert into admin_emp(empno,ename,deptno) values(emp_sequence.NEXTVAL,'sgwood',120);
insert into admin_emp(empno,ename,deptno) values(emp_sequence.NEXTVAL,'sgwood',emp_sequence.CURRVAL);
insert into admin_emp(empno,ename,deptno) values(emp_sequence.CURRVAL,'sgwood',emp_sequence.NEXTVAL);
SQL> select empno,ename,deptno from admin_emp ;

     EMPNO ENAME               DEPTNO
---------- --------------- ----------
         1 2                        3
         2 sgwood                 120
         3 sgwood                 120
         4 sgwood                 120
         5 sgwood                 120
         6 sgwood                 120

已选择6行。

创建视图sales_staff:
create view sales_staff as
select empno,ename,deptno
from admin_emp
where  deptno=120
with check option constraint sales_staff_cnst;
insert into sales_staff values(7788,'OSTER',120); OK!
insert into sales_staff values(7788,'OSTER',12);
select * from sales_staff;

select view_name,text_length,text from dba_views where view_name='SALES_STAFF';

select column_name,data_type,data_length,last_analyzed from dba_tab_columns where owner='SCOTT' and TABLE_name='EMP';

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 24 Feb 2008 10:42:35 +0800 http://sgwood.javaeye.com/blog/164551 http://sgwood.javaeye.com/blog/164551 77go论坛性能测试 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/164549  发表时间: 2008年02月24日

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

主要是些SQL测试，记录如下：

77go(网络查询): ID(index),ID1,ID2(index)皆为bigint(13) not null default (0),title varchar(200) null(yes)
select ID from bbscs_forum_2
0 row affected .1 field ,26829 records in last resultset. Time: 4.50sec
第二次:                                                     4.8
三：4.89
四 4.42
五：4.58
六：4.72
7: 4.78
8: 5.28
9: 6.92
10: 4.98
11: 4.47

select ID2,ID3 from bbscs_forum_2
.............2 fields, 26829 records                     7.77sec
2: 7.58sec
3:7.63sec
4: 8.27sec
5:7.92sec
6:7.83sec
7:7.77sec
8:7.86sec

select ID,ID1,ID2 from bbscs_forum_2
..................3 fields ,.......................11.31sec
2:10.92
3:11.48
4:11.08
5:10.86

select title from bbscs_forum_2
1:8.94
2:8.89
3:9.13
4:8.83
5:9.02sec
6:8.98sec

select detail  from bbscs_forum_2  where id<40000
1:0.14sec(193个数据)
2:0.13sec

select detail from bbscs_forum_2  (detail:text )
1:20.09 内容举例：post_21190_170_21190_1140543448796.html
2:20.39(无空记录)
3:20.08
4:20.66

select sign from bbscs_forum_2(sign为text)
1:3.64
2:3.64(可能有许多空记录,其中24454为空）
3:3.98

select lastPostTitle from bbscs_forum_2 (varchar(510))
1:3.52(可能是大多内容少成"---"吧）
2:3.64
3:3.33
select Amend from bbscs_forum_2 (与lastPostTitle一样)
1:2.23
2:2.14
3:2.39 (内容全为空）

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Sun, 24 Feb 2008 10:40:34 +0800 http://sgwood.javaeye.com/blog/164549 http://sgwood.javaeye.com/blog/164549 Maven入门--较复杂的实例 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/164107  发表时间: 2008年02月22日

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

本文将使用一个较复杂的实例，讲述如何定制目录布局(即不使用Maven标准目录布局)，以及讲述一些关键插件的使用(配置)。为了方便其它朋友能够方便地使用该实例，后台数据库使用开源的面向对象数据库--db4o，该数据库无需安装，已包含在与本文配套的实例中，文末附有该实例的下载链接。(2007.01.02最后更新)
注：转载出处(http://www.blogjava.net/jiangshachina)！

1 实例的构想
文章开头的摘要已经讲述了，本文仍然将以一个实例描述如何使用Maven， 该实例将使用非Maven标准的目录结构，并将呈现一些关键的Maven插件的配置与应用。 该实例是一个基于db4o的数据库Web应用。该应用本身十分简单，即从db4o数据库中查询出若干记录并将它们显现在Web页面中。
    该实例仍然由一个普通应用工程(demo-app)与一个Web应用工程(demo-web)，以及这两个工程的父工程(demo)构成，最终的目标是将Web应用工程制作成war文件，并部署到JBoss服务器中。启动服务器后，能够在页面中看到正确的查询结果。
    该实例使用Eclipse3.2 + JDK1.5.0_10 + Windows2000开发。当然这仅仅只是我个人的开发平台，但该实例并不受限于此平台；由于我选择使用db4o针对JDK1.5的产品包，所以该实例只能运行在JDK1.5.0或更高版本的JDK/JRE中； 该工程中的所有文件都使用UTF-8编码方式。

2 demo工程
demo工程是其它两个工程的父工程，它的主要职责是预定义子工程所需要依赖的jar文件(artifact)，以及针对子工程所使用的插件进行通用配置。该工程完整的POM文件如下所示：
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>mvn.demo</groupId>
    <artifactId>demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <description>Maven Demo Project</description>

    <modules>
        <module>demo-app</module>
        <module>demo-web</module>
    </modules>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>mvn.demo</groupId>
                <artifactId>demo-app</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>mvn.demo</groupId>
                <artifactId>demo-web</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.db4o</groupId>
                <artifactId>db4o-java5</artifactId>
                <version>5.5</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>2.4</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>commons-configuration</groupId>
                <artifactId>commons-configuration</artifactId>
                <version>1.2</version>
                <exclusions>
                    <exclusion>
                        <groupId>dom4j</groupId>
                        <artifactId>dom4j</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>xml-apis</groupId>
                        <artifactId>xml-apis</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>xalan</groupId>
                        <artifactId>xalan</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>xerces</groupId>
                        <artifactId>xercesImpl</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
        <groupId>junit</groupId>
         <artifactId>junit</artifactId>
           <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.5</source>
                    <target>1.5</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <configuration>
                    <charset>UTF16</charset>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
    预定义工程的依赖关系，就是把会被子工程依赖的artifact的详细信息(groupId，artifactId，version，...)先声明到<dependencyManagement>中。然后子工程只需要声明使用某个artifact就可以了，即那时只需要设置groupId和artifactId(甚至更少)就可以了。 <dependencyManagement>中声明的artifact并不一定真的会被使用到。
2.1 声明依赖关系
    根据实际情况， 该实例 需要使用db4o针对java5的产品包(jar文件)。由于该jar文件并不存在于Maven的中央仓库中，所以我们不能直接通过Maven获得该jar文件。我们只能另外下载db4o-5.5(Java版)的压缩包，然后从压缩包内获得db4o-java5.jar。得到该jar后，必须先将它安装到Maven的本地仓库中(安装方法参见资源[1]，主题"向本地仓库安装文件时要生成POM文件")，以备后面的使用。此处将该artifact的groupId定义为com.db4o，artifactId定义为db4o-java5，version自然就是5.5了(请见上述POM脚本)。
    由于该实例最终是一个Web应用，所以它至少需要依赖Servlet的包(servlet-api-2.4.jar)，还需要commons-configuration-1.2.jar。这两个artifact都已经存在于Maven中央仓库中，所以我查找到它们后，按照Maven中央仓库的命名将它们声明到了<dependencyManagement>中(请见上述POM脚本)。junit是进行单元测试时使用的artifact，(假设)它肯定会被每个工程使用，所以没有将它设置到 <dependencyManagement>中，而直接设置到了 <dependency>中。
    细心的朋友肯定已经发现了，针对 commons-configuration的依赖声明处多了一些语句。从表面上看，应该是排除了4个artifact(dom4j， xml-apis ， xalan 和 xerces )。不错，就是排除了这4个jar文件(artifact)。如果有兴趣的话，可以将整个<exclusions>元素删除，然后再尝试一下制作war文件。你会发现在WEB-INF/lib目录下存在着这4个artifact对应的jar文件。那我为什么要将它们“排除”呢？因为，它们是多余的！即，它们对于我的这个Web应用来说，根本就是无用的！
    Maven2加入了一个很好的特性：自动加载“依赖的依赖(Transitive Dependency)”。以commons-configuration为例。为了能够让它运行正常，我们实际上还需要其它一些jar(artifact)，如commons-collections，commons-lang，...。但这些artifact我都没有“显示”地声明需要依赖它们，但Maven会自动加载，因为 commons-configuration的POM文件将它们声明为了dependency 。
    既然那个4个artifact是commons-configuration的依赖，为什么会认为它们是无用的呢？实际上，它们就不应该被声明到commons-configuration的依赖关系中。这是commons-configuration开发者的失误，他们没有将依赖关系整理清晰，而将一些确实既不是runtime，更不是compile-time需要的artifact放入到了依赖关系中。在Maven中央仓库中存在着很多这种情况，所以我们有时需要弄清楚“哪些文件是我们真正需要的，哪些是可以被清除的”。但有时候，很难做到一个不漏。正是由于这一原因，自动加载Transitive Dependency这一极好的特性，有时让人十分无奈 ^_^
2.2 对插件进行基本配置
我们可以把对插件的全局性(如针对整个项目的)设置放到较高层次的POM文件中，因为它们被设置后，子工程们就会自然遵守它们，而且可以使每个子工程的情况都是一样的。
    在第1节中，已经表明该工程使用JDK1.5平台，并且所有文件都使用UTF-8的编码方式。而Maven默认使用JDK1.3级别的javac编译器；默认使用本地编码方式(简体中文Windows操作系统默认使用GBK编码方式)处理文件。这样就必须对Maven进行适当设置，以满足工程的实际需要。
    针对资源文件的处理，Maven使用maven-resources-plugin插件，需要将它的编码方式设置为UTF-8。编译Java源文件，是使用maven-compiler-plugin插件，需要将它的source(Java源文件)与target(class文件)的级别都设置为1.5，另外还要将它的encoding方式设置为UTF-8。（详细设置请见POM脚本）

3 demo-app工程
demo-app工程是一个普通应用程序工程，它用于处理和数据库相关的操作，如针对数据库的增、删、改、查等基本功能。该工程POM文件的主要内容如下所示：
<project>
    ......
    <build>
        <finalName>app</finalName>
        <directory>target</directory>

        <sourceDirectory>src/java</sourceDirectory>
        <outputDirectory>target/classes</outputDirectory>
        <resources>
            <resource>
                <directory>src/java</directory>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
        </resources>

        <testSourceDirectory>src/test/java</testSourceDirectory>
        <testOutputDirectory>target/test-classes</testOutputDirectory>
        <testResources>
            <testResource>
                <directory>src/test/java</directory>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </testResource>
        </testResources>
    </build>
</project>
    文章的开头已经提到，本实例将会使用定制的目录结构，但在前面却一字不提此事，现在将描述如何定制目录结构。Maven的标准目录结构其实是在Super POM中设置的，由于任何POM都会继承该POM，所以所有的工作都会默认使用标准目录结构。要定制目录，其实就是需要重新设置相关参数的值，即用新值覆盖Super POM中的值。
[1]<finalName>，该元素指定了工程输出的artifact的名称，默认值为${artifactId}-${version}，此处修改为app。
[2]<directory>，该元素指定了工程输出的目标目录。默认值为target，此处未修改变。
[3]<sourceDirectory>，该元素指定了Java源文件所在的目录。默认值为src/main/java，此处修改为src/java。
[4]<outputDirectory>，该元素指定了编译后的class文件的放置目录。默认值为target/classes，此处未作改变。
[5]<resources> <resource>，该元素指定了Java源文件使用的资源文件的存放目录。默认值为src/main/resources，此处修改为src/java。由于在编码Java源文件时，Maven会将资源路径中的文件全部拷贝到classes目录。而此时将Java资源文件目录与Java源文件目录，设置为同一目录，所以需要将.java文件排除在资源文件的范畴之外( <exclude>**/*.java</exclude> )。
[6] <testSourceDirectory>，该元素指定了单元测试Java源文件的放置目录。默认值为src/test/java，此处未作修改。
[7] <testOutputDirectory>，该元素指定了单元测试Java源文件编译后的class文件放置目录。默认值为 target/test-classes，此处未作改变。
[8] <testResources> <testResource>，该元素指定了单元测试Java源文件所使用的资源文件的放置目录。默认值为src/test/resources，此处修改为 src/test/java。并且也做了与 设置<resources> <resource>时相同的处理(排除Java源文件)。
    通过上述设置后，就可以拥有一个定制的Maven工程目录结构了。

4 demo-web工程
demo-web工程是整个应用最终的目标输出，因为此处的目的就是制作一个war文件，然后将它部署到JBoss服务器中。与demo-app工程相比，demo-web工程的POM文件主要有如下不同内容：
<project >
    ......
    <build>
        ......
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version> 2.0.1 </version>
                <configuration>
                    <webappDirectory>target/${artifactId}</webappDirectory>
                    <warSourceDirectory>src/webapp</warSourceDirectory>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>jboss-maven-plugin</artifactId>
                <version> 1.3.1 </version>
                <configuration>
                    <jbossHome>E:/jboss- 4.0.2 </jbossHome>
                    <serverName>default</serverName>
                    <fileName>
                        ${project.build.directory}/${project.build.finalName}.${project.packaging}
                    </fileName>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
可以看出不同之处就在于对maven-war-plguin及jboss-maven-plugin插件的配置与使用。
    Maven使用maven-war-plugin插件对Web工程制作war文件。由于本文使用了定制目录结构，这样则会使maven-war-plugin无法找到Web工程的Web Root目录(默认是src/main/webapp)，所以需要对该插件进行适当地配置。<warSourceDirectory>就是Web工程的Web Root目录，此处设置为；<webappDirectory>是制作war文件之前，相当于是一个被打开(exploded)的war文件的根目录(默认是target/artifactId-version)。
    该工程的脚本中，还使用了一个JBoss插件。该插件可以将制作好的war文件部署(实质上是拷贝)到指定的JBoss部署目录中。<jbossHome>是JBoss的安装根目录，<serverName>指JBoss Server的名称，<fileName>是被部署war文件的名称。

参考资源
[1]Maven入门--概念与实例. http://www.blogjava.net/jiangshachina/archive/2006/09/01/67080.html
[2]Maven + Continuum Weed. http://www.blogjava.net/jiangshachina/archive/2006/09/11/68944.aspx
[3]Maven POM Reference. http://maven.apache.org/pom.html
[3]db4o. http://www.db4objects.com
本文实例下载地址--http://www.blogjava.net/files/jiangshachina/mvn-demo.rar

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Fri, 22 Feb 2008 10:38:12 +0800 http://sgwood.javaeye.com/blog/164107 http://sgwood.javaeye.com/blog/164107 Maven入门--概念与实例 sgwood 作者: sgwood  链接：http://sgwood.javaeye.com/blog/164103  发表时间: 2008年02月22日

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

    本文虽然是Maven2的入门文章，但并不涉及Maven的历史、下载与安装，这些内容可以到Maven的官方网站上了解。本文主要是关注Maven中的重要概念，并以一个实例来阐述使用Maven的基本方法。文末有例子代码下载的链接。(2007.01.02最后更新)
注：转载出处(http://www.blogjava.net/jiangshachina)！

1 关键名词
    Project：任何您想build的事物，Maven都可以认为它们是工程。这些工程被定义为工程对象模型(POM，Poject Object Model)。一个工程可以依赖其它的工程；一个工程也可以由多个子工程构成。
    POM：POM(pom.xml)是Maven的核心文件，它是指示Maven如何工作的元数据文件，类似于Ant中的build.xml文件。POM文件位于每个工程的根目录中。
    GroupId：groupId是一个工程的在全局中唯一的标识符，一般地，它就是工程名。groupId有利于使用一个完全的包名，将一个工程从其它有类似名称的工程里区别出来。
    Artifact：artifact是工程将要产生或需要使用的文件，它可以是jar文件，源文件，二进制文件，war文件，甚至是pom文件。每个artifact都由groupId和artifactId组合的标识符唯一识别。需要被使用(依赖)的artifact都要放在仓库(见Repository)中，否则Maven无法找到(识别)它们。
    Dependency：为了能够build或运行，一个典型的Java工程会依赖其它的包。在Maven中，这些被依赖的包就被称为dependency。dependency一般是其它工程的artifact。
    Plug-in：Maven是由插件组织的，它的每一个功能都是由插件提供的。插件提供goal(类似于Ant中的target)，并根据在POM中找到的元数据去完成工作。主要的Maven插件要是由Java写成的，但它也支持用Beanshell或Ant脚本写成的插件。
    Repository：仓库用于存放artifact，它可以是本地仓库，也可以是远程仓库。Maven有一个默认的远程仓库--central，可以从http://www.ibiblio.org/maven2/下载其中的artifact。在Windows平台上，本地仓库的默认地址是User_Home\.m2\repository。
    Snapshot：工程中可以(也应该)有一个特殊版本，它的版本号包括SNAPSHOT字样。该版本可以告诉Maven，该工程正处于开发阶段，会经常更新(但还未发布)。当其它工程使用此类型版本的artifact时，Maven会在仓库中寻找该artifact的最新版本，并自动下载、使用该最新版。
2 Maven Build Life Cycle
    软件项目一般都有相似的开发过程：准备，编译，测试，打包和部署，Maven将上述过程称为Build Life Cycle。在Maven中，这些生命周期由一系列的短语组成，每个短语对应着一个(或多个)操作；或对应着一个(或多个)goal(类似于Ant中的target)。
    如编译源文件的命令mvn compile中的compile是一个生命周期短语。同时该命令也可以等价于mvn compiler:compile，其中的compiler是一个插件，它提供了compile(此compile与mvn compile中的compile意义不同)goal；compiler还可提供另一个goal--testCompile，该goal用于编译junit测试类。
    在执行某一个生命周期时，Maven会首先执行该生命周期之前的其它周期。如要执行compile，那么将首先执行validate，generate-source，process-source和generate-resources，最后再执行compile本身。关于Maven中默认的生命周期短语，请见参考资源[6]中的附录B.3。
3 标准目录布局
    Maven为工程中的源文件，资源文件，配置文件，生成的输出和文档都制定了一个标准的目录结构。Maven鼓励使用标准目录布局，这样就不需要进行额外的配置，而且有助于各个不同工程之间的联接。当然，Maven也允许定制个性的目录布局，这就需要进行更多的配置。关于Maven的标准目录布局，请见参考资源[6]中的附录B.1。
4 Maven的优点
    [1]build逻辑可以被重用。在Ant中可能需要多次重复地写相同的语句，但由于POM的继承性，可以复用其它的POM文件中的语句。这样既可以写出清晰的build语句，又可以构造出层次关系良好的build工程。
    [2]不必关注build工作的实现细节。我们只需要使用一些build生命周期短语就可以达到我们的目标，而不必管Maven是如何做到这些的。如，只需要告诉Maven要安装(install)，那么它自然就会验证，编译，打包，及安装。
    [3]Maven会自动加载工程依赖的artifact所依赖的其它artifact(Transitive Dependency)，而不用显示的将这些artifact全部写到dependency中。
    [4]如果完全使用Maven的标准目录布局，那么可以极大地减少配置细节。
5 实例
5.1 构想
    由于只是阐述Maven的基本使用方法，所以本文将要设计的实例，只是一个简单的Maven demo。该实例包含两个工程：普通应用程序工程(app)和Web应用工程(webapp)。app工程提供一个简单的Java类；webapp工程只包含一个Servlet，并将使用app中的Java类。
    该Demo的目标是能够正确地将webapp制成war包，以供部署时使用。要能够正确制作war，自然首先就必须要能够正确的编译源代码，且要将App模块制成jar包。本文创建的工程所在的目录是D:\maven\demo。
5.2 App工程
    可以使用Maven的archetype插件来创建新工程，命令如下：
    D:\maven\demo>mvn archetype:create -DgroupId=ce.demo.mvn -DartifactId=app
该工程的groupId是ce.demo.mvn，那么该工程的源文件将放在Java包ce.demo.mvn中。artifactId是app，那么该工程根目录的名称将为app。
    当第一次执行该命令时，Maven会从central仓库中下载一些文件。这些文件包含插件archetype，以及它所依赖的其它包。该命令执行完毕后，在目录D:\maven\demo下会出现如下目录布局：
app
|-- pom.xml
`-- src
    |-- main
    |   `-- java
    |       `-- ce
    |           `-- demo
    |               `-- mvn
    |                   `-- App.java
    `-- test
        `-- java
            `-- ce
                `-- demo
                    `-- mvn
                        `-- AppTest.java
因本文暂时不涉及JUnit测试，故请将目录app\src\test目录删除(不删除也没关系 ^_^)。然后再修改App.java文件，其完全内容如下：
package ce.demo.mvn;
public class App {
    public String getStr(String str) {
        return str;
    }
}
其实，如果我们能够清楚地知道Maven的标准目录布局，就可以不使用archetype插件来创建工程原型；如果我们要定制个性的目录布局，那么就更没有必要使用archetype插件了。
5.3 WebApp工程
    我们仍然如创建app工程一样使用archetype插件来创建webapp工程，命令如下：
    D:\maven\demo>mvn archetype:create -DgroupId=ce.demo.mvn -DartifactId=webapp -DarchetypeArtifactId=maven-archetype-webapp
    第一次运行此命令时，也会从central仓库中下载一些与Web应用相关的artifact(如javax.servlet)。此命令与创建app的命令的不同之处是，多设置了一个属性archetypeArtifacttId，该属性的值为maven-archetype-webapp。即告诉Maven，将要创建的工程是一个Web应用工程。创建app工程时没有使用该属性值，是由于archetype默认创建的是应用程序工程。同样的，执行完该命令之后，会出现如下标准目录布局：
webapp
|-- pom.xml
`-- src
    `-- main
        `-- webapp
            |-- index.jsp
            |-- WEB-INF
                `-- web.xml
    根据5.1节的构想，webapp工程将只包含一个Servlet，所以我们不需要index.jsp文件，请将其删除。此时大家可以发现，目前的目录布局中并没有放Servlet，即Java源文件的地方。根据参考资源[6]中的附录B.1，以及app工程中Java源文件的布局，可以知道Servlet（它仍然是一个Java类文件）仍然是放在webapp\src\main\java目录中，请新建该目录。此处的Servlet是一个简单HelloServlet，其完整代码如下：
package hello;

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;