|
我的评论
芦苇 2010-02-23 11:32
我知道这些代码是有问题的,而且也是我转别人的文章,但是我使用的时候就是参考这个弄出来的,一个正常的代码,你拷贝过去完全正常使用,你还能学到什么?只有出错了,你自己解决了,你才学到了东西.
另外:这里是我的私人博客,是我收集一些资料的地方,没有你想要的东西很正常啊,请不要出口伤人!
芦苇 2009-07-02 17:01
styletest
这个类里面红叉叉,不知道开发的时候用的jdk是哪个版本,我的jdk1.5的java.awt.font怎么没有font.dialog常量?
芦苇 2008-11-04 18:38
openid server
http://code.google.com/p/openid-server/
http://www.movabletype.org/download.html
客户端插件:
http://openid4java.googlecode.com/svn/trunk
芦苇 2008-11-04 18:28
因为经常看到有openid的吹捧者，所以本来希望写一个openid的blog，引起大家的注意，然后从他们哪儿获得一些关于openid详细协议的资料，可惜失算了。
不得以，今天早上，花了一些时间，在词典的帮助下用我蹩脚的英语翻译了一下。终于搞明白了openid的加密验证模式。
最关键的是第三步和第七步。这两步由应用服务器任选其一，他们都是应用服务器直接与身份验证服务器交互，第三步是获得并保存一个密匙，用于严整用户所传递的数据是否合法。第七步则是直接把接受的信息交个身份验证服务器，然后由身份验证服务器来验证这个信息是否合法。
这样以来，我前边所讲的哪个hack的模式就的确是行不通的了。
———以下是我翻译的全文———
一个带图片说明的openid协议介绍
a description of the openid protocol with diagrams.
1: user submits identity url
1：用户提交身份地址
the consumer uses a form with get or post to allow the user to enter their openid url.
应用服务器通过get或者post方法获得用户提交他们的openid地址(身份地址)
2: consumer fetches identity url
2:应用服务器取得身份验证服务器
the consumer parses the html content and looks for a tag:
应用服务器解吸用户提交的地址的数据中的html标签:（其中the server 就是身份验证服务器）
3: consumer associates with server (option 1)
3:应用服务器与身份验证服务器交互（选项1）
in order to communicate securely with the server, the consumer gets an association with the server discovered in step 2, using an existing association if it is available, otherwise visiting the server and using diffie hellman to negotiate a shared secret with which to sign communication. a consumer unable to store state uses "dumb mode" which does not perform this step, and instead uses step 7.
为了能够与身份验证服务器安全的通信，应用服务器需要向（从第2步获取的）身份验证服务器请求一个协议。如果有现成的可以使用的协议，则用现有的协议，否则，通过diffie hellman的方法获得一个共享密匙，静默模式（dumb mode）下的应用服务器不需要这一步，而是使用第7步的操作。
4: consumer redirects the user to the server
4：应用服务器将用户重定向到身份验证服务器
the openid server url accepts a query, containing all the information the server needs to check the user's identity and redirect the user back to the consumer. the server checks the authentication of the user. if the user is signed in (has an auth cookie) and has already authorized sending their identity to the consumer, step 5 may be skipped.
openid服务器接受一个包含所有应用服务器需要用来验证用户的信息，如果用户已经登陆（有cookie）并且他已经同意发送他的身份信息给应用服务器的话，第5步可以跳过。
5: user authenticates to server
5:用户鉴别是否是自己访问的服务
the user authenticates to the server with a cookie or a username and password, and the server asks the user for permission to send their identity information to the consumer.
通过cookie或者用户名 密码验证当前用户是否登陆，并且询问当前用户是否允许应用服务器获得自己的身份信息。
6: server redirects the user back to the consumer
6: 身份验证服务器重定向用户到应用服务器
the consumer parses the servers response (which is appended to the return-to url the consumer sent) and verifies it using the association, or in the case of dumb mode proceeds to step 7.
应用服务器使用获得的身份验证服务器的协议，校验并解析所返回的数据。如果在静默模式（dumb mode）下，继续第7步。
7: consumer verifies the response with the server (option 2)
7:应用服务器通过身份验证服务器校验接收到的信息（选项2）
communicating directly with the server, the dumb mode consumer checks the response received via the user agent in the redirect.
应用服务器直接连接身份验证服务器校验接受到的信息，在静默模式下的应用服务器使用重定向的方法通过身份地址(user agent)核对接受到的信息。
trackback: http://tb.donews.net/trackback.aspx?postid=1085110
芦苇 2008-10-27 11:32
spring框架下自带了丰富的工具类,在我们开发时可以简化很多工作:
1.resource访问文件资源:
具体有:resourceutils.getfile(url);
filesystemresource(); classpathresource();
servletcontextresource(application,url);
2.文件操作 filecopyutils
具体有:filecopyutils.copy(resource.getfile,new file(resource.getfile(),getparent() '目标文件名'));
3.属性文件操作 propertiesloaderutils
具体有: propertiesloaderutils.loadallproperties("属性文件名"); --基于类路径
4.encodedresource(resource对象,"utf-8") 编码资源(特殊的);
5.webapplicationcontextutils
6.webutils
具体有:getcookie, getsessionattribute, getrealpath;
7.stringescapeutils 编码解码
芦苇 2008-10-14 18:13
sql方言
1、hibernate jdbc属性
| 属性名 |
用途 |
| hibernate.connection.driver_class |
jdbc驱动类 |
| hibernate.connection.url |
jdbc url |
| hibernate.connection.username |
数据库用户 |
| hibernate.connection.password |
数据库用户密码 |
| hibernate.connection.pool_size |
连接池容量上限数目 |
注：使用c3p0的properties样例代码：
hibernate.connection.driver_class = org.postgresql.driver
hibernate.connection.url = jdbc:postgresql://localhost/mydatabase
hibernate.connection.username = myuser
hibernate.connection.password = secret
hibernate.c3p0.min_size=5
hibernate.c3p0.max_size=20
hibernate.c3p0.timeout=1800
hibernate.c3p0.max_statements=50
hibernate.dialect = org.hibernate.dialect.postgresqldialect
2、hibernate的数据源属性
| 属性名 |
用途 |
| hibernate.connection.datasource |
数据源jndi名字 |
| hibernate.jndi.url |
jndi提供者的url (可选) |
| hibernate.jndi.class |
jndi initialcontextfactory类 (可选) |
| hibernate.connection.username |
数据库用户 (可选) |
| hibernate.connection.password |
数据库用户密码 (可选) |
注：应用程序服务器jndi数据源的 hibernate.properties样例代码：
hibernate.connection.datasource = java:/comp/env/jdbc/test
hibernate.transaction.factory_class = \
org.hibernate.transaction.jtatransactionfactory
hibernate.transaction.manager_lookup_class = \
org.hibernate.transaction.jbosstransactionmanagerlookup
hibernate.dialect = org.hibernate.dialect.postgresqldialect
3、 hibernate配置属性（可选）
| 属性名 |
用途 |
| hibernate.dialect |
一个hibernate dialect类名允许hibernate针对特定的关系数据库生成优化的sql.
取值full.classname.of.dialect
|
| hibernate.show_sql |
输出所有sql语句到控制台.
取值true | false
|
| hibernate.format_sql |
在log和console中打印出更漂亮的sql.
取值true | false
|
| hibernate.default_schema |
在生成的sql中, 将给定的schema/tablespace附加于非全限定名的表名上.
取值schema_name
|
| hibernate.default_catalog |
在生成的sql中, 将给定的catalog附加于没全限定名的表名上.
取值catalog_name
|
| hibernate.session_factory_name |
sessionfactory创建后，将自动使用这个名字绑定到jndi中.
取值jndi/composite/name
|
| hibernate.max_fetch_depth |
为单向关联(一对一, 多对一)的外连接抓取（outer join fetch）树设置最大深度. 值为0意味着将关闭默认的外连接抓取.
取值 建议在0到3之间取值
|
| hibernate.default_batch_fetch_size |
为hibernate关联的批量抓取设置默认数量.
取值 建议的取值为4, 8, 和16
|
| hibernate.default_entity_mode |
为由这个sessionfactory打开的所有session指定默认的实体表现模式.
取值dynamic-map, dom4j, pojo
|
| hibernate.order_updates |
强制hibernate按照被更新数据的主键，为sql更新排序。这么做将减少在高并发系统中事务的死锁。
取值true | false
|
| hibernate.generate_statistics |
如果开启, hibernate将收集有助于性能调节的统计数据.
取值true | false
|
| hibernate.use_identifer_rollback |
如果开启, 在对象被删除时生成的标识属性将被重设为默认值.
取值true | false
|
| hibernate.use_sql_comments |
如果开启, hibernate将在sql中生成有助于调试的注释信息, 默认值为false.
取值true | false
|
4、 hibernate jdbc和连接(connection)属性
| 属性名 |
用途 |
| hibernate.jdbc.fetch_size |
非零值，指定jdbc抓取数量的大小 (调用statement.setfetchsize()). |
| hibernate.jdbc.batch_size |
非零值，允许hibernate使用jdbc2的批量更新.
取值 建议取5到30之间的值
|
| hibernate.jdbc.batch_versioned_data |
如果你想让你的jdbc驱动从executebatch()返回正确的行计数 , 那么将此属性设为true(开启这个选项通常是安全的). 同时，hibernate将为自动版本化的数据使用批量dml. 默认值为false.
eg.true | false
|
| hibernate.jdbc.factory_class |
选择一个自定义的batcher. 多数应用程序不需要这个配置属性.
eg.classname.of.batcher
|
| hibernate.jdbc.use_scrollable_resultset |
允许hibernate使用jdbc2的可滚动结果集. 只有在使用用户提供的jdbc连接时，这个选项才是必要的, 否则hibernate会使用连接的元数据.
取值true | false
|
| hibernate.jdbc.use_streams_for_binary |
在jdbc读写binary (二进制)或serializable (可序列化) 的类型时使用流(stream)(系统级属性).
取值true | false
|
| hibernate.jdbc.use_get_generated_keys |
在数据插入数据库之后，允许使用jdbc3 preparedstatement.getgeneratedkeys() 来获取数据库生成的key(键)。需要jdbc3 驱动和jre1.4 , 如果你的数据库驱动在使用hibernate的标 识生成器时遇到问题，请将此值设为false. 默认情况下将使用连接的元数据来判定驱动的能力.
取值true|false
|
| hibernate.connection.provider_class |
自定义connectionprovider的类名, 此类用来向hibernate提供jdbc连接.
取值classname.of.connectionprovider
|
| hibernate.connection.isolation |
设置jdbc事务隔离级别. 查看java.sql.connection来了解各个值的具体意义, 但请注意多数数据库都不支持所有的隔离级别.
取值1, 2, 4, 8
|
| hibernate.connection.autocommit |
允许被缓存的jdbc连接开启自动提交(autocommit) (不建议).
取值true | false
|
| hibernate.connection.release_mode |
指定hibernate在何时释放jdbc连接. 默认情况下,直到session被显式关闭或被断开连接时,才会释放jdbc连接. 对于应用程序服务器的jta数据源, 你应当使用after_statement, 这样在每次jdbc调用后，都会主动的释放连接. 对于非jta的连接, 使用after_transaction在每个事务结束时释放连接是合理的. auto将为jta和cmt事务策略选择after_statement, 为jdbc事务策略选择after_transaction.
取值on_close | after_transaction | after_statement | auto
|
| hibernate.connection. |
将jdbc属性propertyname传递到drivermanager.getconnection()中去. |
| hibernate.jndi. |
将属性propertyname传递到jndi initialcontextfactory中去. |
5、hibernate缓存属性
| 属性名 |
用途 |
| hibernate.cache.provider_class |
自定义的cacheprovider的类名.
取值classname.of.cacheprovider
|
| hibernate.cache.use_minimal_puts |
以频繁的读操作为代价, 优化二级缓存来最小化写操作. 在hibernate3中，这个设置对的集群缓存非常有用, 对集群缓存的实现而言，默认是开启的.
取值true|false
|
| hibernate.cache.use_query_cache |
允许查询缓存, 个别查询仍然需要被设置为可缓存的.
取值true|false
|
| hibernate.cache.use_second_level_cache |
能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定的类，会默认开启二级缓存.
取值true|false
|
| hibernate.cache.query_cache_factory |
自定义的实现querycache接口的类名, 默认为内建的standardquerycache.
取值classname.of.querycache
|
| hibernate.cache.region_prefix |
二级缓存区域名的前缀.
取值prefix
|
| hibernate.cache.use_structured_entries |
强制hibernate以更人性化的格式将数据存入二级缓存.
取值true|false
|
6、 hibernate事务属性
| 属性名 |
用途 |
| hibernate.transaction.factory_class |
一个transactionfactory的类名, 用于hibernate transaction api (默认为jdbctransactionfactory).
取值classname.of.transactionfactory
|
| jta.usertransaction |
一个jndi名字，被jtatransactionfactory用来从应用服务器获取jta usertransaction.
取值jndi/composite/name
|
| hibernate.transaction.manager_lookup_class |
一个transactionmanagerlookup的类名 - 当使用jvm级缓存，或在jta环境中使用hilo生成器的时候需要该类.
取值classname.of.transactionmanagerlookup
|
| hibernate.transaction.flush_before_completion |
如果开启, session在事务完成后将被自动清洗(flush). (在hibernate和cmt一起使用时很有用.)
取值true | false
|
| hibernate.transaction.auto_close_session |
如果开启, session在事务完成前将被自动关闭. (在hibernate和cmt一起使用时很有用.)
取值true | false
|
7、 其他属性
| 属性名 |
用途 |
| hibernate.query.factory_class |
选择hql解析器的实现.
取值org.hibernate.hql.ast.astquerytranslatorfactory or org.hibernate.hql.classic.classicquerytranslatorfactory
|
| hibernate.query.substitutions |
将hibernate查询中的符号映射到sql查询中的符号 (符号可能是函数名或常量名字).
取值hqlliteral=sql_literal, hqlfunction=sqlfunc
|
| hibernate.hbm2ddl.auto |
在sessionfactory创建时，自动将数据库schema的ddl导出到数据库. 使用 create-drop时,在显式关闭sessionfactory时，将drop掉数据库schema.
取值update | create | create-drop
|
| hibernate.cglib.use_reflection_optimizer |
开启cglib来替代运行时反射机制(系统级属性). 反射机制有时在除错时比较有用. 注意即使关闭这个优化, hibernate还是需要cglib. 你不能在hibernate.cfg.xml中设置此属性.
取值true | false
|
8、 sql方言
hibernate sql方言 (hibernate.dialect)
| rdbms |
方言 |
| db2 |
org.hibernate.dialect.db2dialect |
| db2 as/400 |
org.hibernate.dialect.db2400dialect |
| db2 os390 |
org.hibernate.dialect.db2390dialect |
| postgresql |
org.hibernate.dialect.postgresqldialect |
| mysql |
org.hibernate.dialect.mysqldialect |
| mysql with innodb |
org.hibernate.dialect.mysqlinnodbdialect |
| mysql with myisam |
org.hibernate.dialect.mysqlmyisamdialect |
| oracle (any version) |
org.hibernate.dialect.oracledialect |
| oracle 9i/10g |
org.hibernate.dialect.oracle9dialect |
| sybase |
org.hibernate.dialect.sybasedialect |
| sybase anywhere |
org.hibernate.dialect.sybaseanywheredialect |
| microsoft sql server |
org.hibernate.dialect.sqlserverdialect |
| sap db |
org.hibernate.dialect.sapdbdialect |
| informix |
org.hibernate.dialect.informixdialect |
| hypersonicsql |
org.hibernate.dialect.hsqldialect |
| ingres |
org.hibernate.dialect.ingresdialect |
| progress |
org.hibernate.dialect.progressdialect |
| mckoi sql |
org.hibernate.dialect.mckoidialect |
| interbase |
org.hibernate.dialect.interbasedialect |
| pointbase |
org.hibernate.dialect.pointbasedialect |
| frontbase |
org.hibernate.dialect.frontbasedialect |
| firebird |
org.hibernate.dialect.firebirddialect |
9、 hibernate日志类别
| 类别 |
功能 |
| org.hibernate.sql |
在所有sql dml语句被执行时为它们记录日志 |
| org.hibernate.type |
为所有jdbc参数记录日志 |
| org.hibernate.tool.hbm2ddl |
在所有sql ddl语句执行时为它们记录日志 |
| org.hibernate.pretty |
在session清洗(flush)时，为所有与其关联的实体(最多20个)的状态记录日志 |
| org.hibernate.cache |
为所有二级缓存的活动记录日志 |
| org.hibernate.transaction |
为事务相关的活动记录日志 |
| org.hibernate.jdbc |
为所有jdbc资源的获取记录日志 |
| org.hibernate.hql.ast |
为hql和sql的自动状态转换和其他关于查询解析的信息记录日志 |
| org.hibernate.secure |
为jaas认证请求做日志 |
| org.hibernate |
为任何hibernate相关信息做日志 (信息量较大, 但对查错非常有帮助) |
芦苇 2008-10-10 11:34
仔细在理解一下,你所述看不到那个按钮?
你是使用tortoisesvn客户端吗?
芦苇 2008-10-10 11:21
@ss
的确是转贴的,没看到最下面的说明吗?这是我的收藏,觉得没用就请你离开
芦苇 2008-03-11 14:09
经过测试的log4j.properties文件---用于数据库的log
log4j.rootlogger = debug,database
log4j.appender.database = org.apache.log4j.jdbc.jdbcappender
log4j.appender.database.driver = oracle.jdbc.driver.oracledriver
log4j.appender.database.url = jdbc:oracle:thin:@192.168.8.2:1521:dssdb
log4j.appender.database.user = tom
log4j.appender.database.password = lizhifeng
log4j.appender.database.layout = org.apache.log4j.patternlayout
log4j.appender.database.layout.conversionpattern = insert into log4j (createdate, thread, priority, category, message) values(sysdate, '%t', '%-5p', '%c', '%m')
芦苇 2008-03-11 14:08
一 最好与commons-logging一起用，why？
1.标准接口，即使将来脱离了log4j也一样用
2.简化了编码，减少耦合度：不需在代码中指定log4j配制文件位置，代码中不需要引用log4j的包
3.基本所有框架都是这么用的。。。。。。（我相信群众）
附加提供一下commons-logging寻找配置文件的顺序（从别人那抄的）
1) 首先在classpath下寻找自己的配置文件commons-logging.properties，如果找到，则使用其中定义的log实现类；
2) 如果找不到commons-logging.properties文件，则在查找是否已定义系统环境变量org.apache.commons.logging.log，找到则使用其定义的log实现类；
3) 否则，查看classpath中是否有log4j的包，如果发现，则自动使用log4j作为日志实现类；
4) 否则，使用jdk自身的日志实现类（jdk1.4以后才有日志实现类）；
5) 否则，使用commons-logging自己提供的一个简单的日志实现类simplelog；
二 具体实现
1.把commons-logging的jar加到classpath中
2.把log4j的jar加到classpath中
3.在classpath的根目录下，建立log4j.properties(必须是这个地方，必须叫这个名,才不用特殊配置)，可以直接复制后边的模板
4.在需要log的类中:
import org.apache.commons.logging.log;
import org.apache.commons.logging.logfactory;
private static log log = logfactory.getlog(xxxx.class);
为什么要使用static？因为避免产生多个实例
为什么不使用this.class？因为是static不能用this（我经常犯这个错误。。。）
为什么不使new xxxx().getclass()？因为。。。。你猜呢？
5.根据实际需要log.debug()、log.info()、log.warn()、log.error()、log.fatal() 就可以输出不同等级的log
三 log的等级
1.为什么需要等级？写代码的时候可能需要很多调试信息，运行的时候可能需要显示提示信息，如果在服务器上发生严重错误的时候，可能需要给管理员发邮件。这种：调试，提示，错误就是等级。
2.都有什么等级？ 调试(debug)<信息(info)<警告(warn)<错误(error)<致命错误(fatal)
3.怎么用？ log.debug() log.info() log.warn() log.error() log.fatal()依次对应上边的等级
四 log4j的配制
1.基本参数解释：
⑴全局配制
log4j.rootlogger = [ level ] , appendername, appendername,..........appendername
★log4j.rootlogger的意思可以理解为：根log或者所有的log
★level就是输出级别，只能设置一个值。
·关于等级，前边已经说过了有5种，他们之间的关系可以理解为：
调试(debug)：包含调试(debug)、信息(info)、警告(warn)、错误(error)、致命错误(fatal)
信息(info)：包含信息(info)、警告(warn)、错误(error)、致命错误(fatal)
警告(warn)：包含警告(warn)、错误(error)、致命错误(fatal)
错误(error)：包含错误(error)、致命错误(fatal)
致命错误(fatal)：只有他自己
这样，如果log4j.rootlogger = info，那么 info，warn，error，fatal就全部会被输出
如果log4j.rootlogger = error，那么error，fatal就全部会被输出
★appendername就是记录的目标,目标可以多个，中间用『,』分割，appendername是自己定义的，换句话说，名字是随便起的，起了名之后，就需要在下边设定具体配制
总结一下这部分，比如说有这么一句log4j.rootlogger = info , f1,f2那么就以为着要将所有info，warn，error，fatal的log全部输出到f1，f2上。f1，f2是什么？往下看。。。。
⑵具体配制
log4j.appender.f1=org.apache.log4j.consoleappender
log4j.appender.f1.layout=org.apache.log4j.patternlayout
log4j.appender.f1.layout.conversionpattern=%d{yyyy-mm-dd hh:mm:ss,sss} [%c]-[%p] %m%n
★log4j.appender.f1=org.apache.log4j.consoleappender的意思就是：将f1设置为控制台输出
·还可以设置成什么？
org.apache.log4j.consoleappender（控制台），
org.apache.log4j.fileappender（文件），
org.apache.log4j.dailyrollingfileappender（每天产生一个日志文件），
org.apache.log4j.rollingfileappender（文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.writerappender（将日志信息以流格式发送到任意指定的地方）
★log4j.appender.f1.layout=org.apache.log4j.patternlayout的意思就是：将f1的输出布局设置为自定义输出布局。
·还可以设置成什么？
org.apache.log4j.htmllayout（以html表格形式布局）
org.apache.log4j.xml.xmllayout（以xml形式布局）
org.apache.log4j.patternlayout（可以灵活地指定布局模式），
org.apache.log4j.simplelayout（包含日志信息的级别和信息字符串），
org.apache.log4j.ttcclayout（包含日志产生的时间、线程、类别等等信息）
★log4j.appender.f1.layout.conversionpattern=%d{yyyy-mm-dd hh:mm:ss,sss} [%c]-[%p] %m%n既然上边定义的是自定义输出布局，那么就要定义一下具体输出什么样了~~上边的%c %p %m 等以%开头的都是模式字符串，除了模式字符串外[]-空格等这些字符会按照原样显示。
·模式字符串解释：
%m:消息本身
%p:消息的级别info，warn，error。。。
%r:从程序开始执行到当前日志产生时的时间间隔（微秒）
%c:输出当前日志动作所在的category名称。例如：如果category名称是"a.b.c","%c{2}"将会输出"b.c". {2}意谓着输出“以点分隔开的category名称的后两个组件”,如果 {n}没有，将会输出整个category名称.
%t:输出当前线程的名称
%x:输出和当前线程相关联的ndc,尤其用到像java servlets这样的多客户多线程的应用中。
%n:输出平台相关的换行符。
%%:输出一个"%"字符
%d:输出日志产生时候的日期，当然可以对日期的格式进行定制。例如：%d{hh:mm:ss,ssss}或者是%d{dd mmm yyyy hh:mm:ss,ssss},如果没有指定后面的格式，将会输出iso8601的格式。
%l:输出位置信息，相当于%c.%m(%f:%l)的组合。
%c:输出日志消息产生时所在的类名，如果类名是“test.page.class1”%c{1}表示输出类名"class1",%c{2}输出"page.class1",而%c则输出"test.page.class1"。
%m:输出日志消息产生时的方法名称
%f:输出日志消息产生时所在的文件名称
%l:输出代码中的行号
·可以在%与模式字符之间加上修饰符来控制其最小宽度、最大宽度、和文本的对齐方式。如：
1) c：指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，默认的情况下右对齐。
2)%-20c:指定输出category的名称，最小的宽度是20，如果category的名称小于20的话，"-"号指定左对齐。
3)%.30c:指定输出category的名称，最大的宽度是30，如果category的名称大于30的话，就会将左边多出的字符截掉，但小于30的话也不会有空格。
4) .30c:如果category的名称小于20就补空格，并且右对齐，如果其名称长于30字符，就从左边交远销出的字符截掉。
总结一下，现在来我们所配制的f1的全部内容
·我们把它配制成了屏幕输出
·输出的布局为：自定义布局
·我们又定义了自定义布局的格式：日期时间（格式为：yyyy-mm-dd hh:mm:ss,sss）[产生该日志的包名类名方法名] [等级] 信息 回车
如果想配制f2为每天产生一个日志文件，并且保存为xml，就这么写：
log4j.appender.f2=org.apache.log4j.dailyrollingfileappender
log4j.appender.f2.layout=org.apache.log4j.xml.xmllayout
这样就可以了吗？当然不是，既然保存为文件。。至少要指定一个文件名吧
log4j.appender.f2.file=c:/logs/log.xml
可以了吗？可以运行了。。。但是。。既然每天都产生一个文件，那么前一天的怎么办呢？
log4j.appender.f2.datepattern=yyyymmdd'.xml.back'
这样log4j会在第一次产生今天的log的同时，将昨天的log备份为 log文件名.扩展名yyyymmdd.xml.back。对应我们这个文件，今天的log到明天有新log产生的时候，就会变为log.xml20070420.xml.back
这样的参数到底有多少？常用的有：
★consoleappender选项
·threshold=warn:指定日志消息的输出最低层次。
·immediateflush=true:默认值是true,意谓着所有的消息都会被立即输出。
·target=system.err：默认情况下是：system.out,指定输出控制台
★fileappender 选项
·threshold=warn:指定日志消息的输出最低层次。
·immediateflush=true:默认值是true,意谓着所有的消息都会被立即输出。
·file=mylog.txt:指定消息输出到mylog.txt文件。
·append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
★rollingfileappender 选项
·threshold=warn:指定日志消息的输出最低层次。
·immediateflush=true:默认值是true,意谓着所有的消息都会被立即输出。
·file=mylog.txt:指定消息输出到mylog.txt文件。
·append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
·maxfilesize=100kb: 后缀可以是kb, mb 或者是 gb. 在日志文件到达该大小时，将会自动滚动，即将原来的内容移到mylog.log.1文件。
·maxbackupindex=2:指定可以产生的滚动文件的最大数。
★dailyrollingfileappender 选项
·threshold=warn:指定日志消息的输出最低层次。
·immediateflush=true:默认值是true,意谓着所有的消息都会被立即输出。
·file=mylog.txt:指定消息输出到mylog.txt文件。
·append=false:默认值是true,即将消息增加到指定文件中，false指将消息覆盖指定的文件内容。
·datepattern='.'yyyy-ww:每周滚动一次文件，即每周产生一个新的文件。当然也可以指定按月、周、天、时和分。即对应的格式如下：
1)'.'yyyy-mm: 每月
2)'.'yyyy-ww: 每周
3)'.'yyyy-mm-dd: 每天
4)'.'yyyy-mm-dd-a: 每天两次
5)'.'yyyy-mm-dd-hh: 每小时
6)'.'yyyy-mm-dd-hh-mm: 每分钟
★patternlayout 选项
·conversionpattern=%m%n :指定怎样格式化指定的消息。
★htmllayout 选项
·locationinfo=true:默认值是false,输出java文件名称和行号
·title=my app file: 默认值是 log4j log messages.
★xmllayout 选项
·locationinfo=true:默认值是false,输出java文件和行号
现在来看一下我们完整的第一个配制文件：
========================================================================================
log4j.rootlogger = info,f1,f2
log4j.appender.f1=org.apache.log4j.consoleappender
log4j.appender.threshold=debug
log4j.appender.f1.target=system.out
log4j.appender.f1.layout=org.apache.log4j.patternlayout
log4j.appender.f1.layout.conversionpattern=%d{yyyy-mm-dd hh:mm:ss,sss} [%c]-[%p] %m%n
log4j.appender.f2=org.apache.log4j.dailyrollingfileappender
log4j.appender.f2.file=c:/logs/log.xml
log4j.appender.f2.datepattern=yyyymmdd-hh'.xml.back'
log4j.appender.f2.layout=org.apache.log4j.xml.xmllayout
========================================================================================
编段代码看看效果
========================================================================================
import org.apache.commons.logging.log;
import org.apache.commons.logging.logfactory;
public class main{
private static log log = logfactory.getlog(main.class);
public static void main(string[] args) throws exception{
log.info("info");
log.debug("debug");
log.warn("warn");
log.error("error");
}
}
========================================================================================
运行效果
========================================================================================
2007-04-20 12:36:22,531 [cn.yyun.test.main]-[info] info
2007-04-20 12:36:22,531 [cn.yyun.test.main]-[warn] warn
2007-04-20 12:36:22,531 [cn.yyun.test.main]-[error] error
========================================================================================
并且在c:/logs/下有log.xml生成，里边的内容为：
========================================================================================
========================================================================================
仔细看一下会发现，虽然我们在代码里写了log.debug("debug")但是debug并没有出现在log中，这是因为我们配置文件中，定义了log的等级为info，debug的等级小于info，所以不会显示，而warn，error的大于info，所以也会被显示出来
2.根据package生成不同的log文件
⑴配置
log4j.logger.cn.yyun.test.abc=info,abc2,abc1
log4j.appender.abc2=org.apache.log4j.consoleappender
log4j.appender.abc2.layout=org.apache.log4j.patternlayout
log4j.appender.abc2.layout.conversionpattern=abc:[%p] %m%n
log4j.appender.abc1=org.apache.log4j.dailyrollingfileappender
log4j.appender.abc1.file=c:/logs/abc.log
log4j.appender.abc1.datepattern='.'yyyymmdd
log4j.appender.abc1.layout=org.apache.log4j.patternlayout
log4j.appender.abc1.layout.conversionpattern=%d %r [%t] %5p - %m%n
log4j.logger.cn.yyun.test.def=info,def
log4j.appender.def=org.apache.log4j.consoleappender
log4j.appender.def.layout=org.apache.log4j.patternlayout
log4j.appender.def.layout.conversionpattern=def: [%p] %m%n
把logger.cn.yyun.test.abc换成需要的package就可以了（整个log4j配制文件中只有这些就可以了 ）。但是这样会有另一个问题，如果cn.yyun.test.main这个类中，如果有log操作，会报告：log4j:warn no appenders could be found for logger (cn.yyun.test.main).所以要加上log4j.rootcategory=info,f1 这样所有的log都会被纪录了。。但是这样又做之后：cn.yyun.test.def里的log，会同时出现在def和f1中，cn.yyun.test.abc里的log，会同时出现在abc1，abc2和f1中。。。。。所以定义的时候一定要规划好。
⑵制定package的log等级
log4j.logger.org.hibernate=debug
芦苇 2008-03-11 14:08
模式字符串简介：
%c：category名称。还可以使用%c{n}的格式输出category的部分名称，其中n为正整数，输出时会从category名称的右侧起查n个"."，然后截取第n个"."右侧的部分输出，例如category的名称为"x.y.z"，指定格式为"%c{2}"，则输出"y.z"。
%c：输出信息时category所在类的名称，也可以使用%c{n}的格式输出。
%d：输出信息的时间，也可以用%d{formatstring}的格式输出，其中formatstring的值请参考ttcclayout的setdateformat方法，但null和relative在%d中无法使用。
%f：输出信息时category所在类文件的名称。
%l：输出信息时category所在的位置，使用"%c.%m(%f:%l)"可以产生同样的效果。
%l：输出信息时category在类文件中的行号。
%m：信息本身。
%m：输出信息时category所在的方法。
%n：换行符，可以理解成回车。
%p：日志级别。
%r：输出信息所用的时间，以毫秒为单位。
%t：当前线程。
%x：输出和当前线程相关的ndc信息。
%x：输出与当前现成相关的mdc信息。
%%：输出%。
此外，还可以在%与模式字符之间加上修饰符来设置输出时的最小宽度、最大宽度及文本对齐方式，例如：
0d{date}：按当前所在地区显示日期和时间，并指定最小宽度为30，当输出信息少于30个字符时会补以空格并右对齐。
%-30d{date}：也是按当前所在地区显示日期和时间，指定最小宽度为30，并在字符少于30时补以空格，但由于使用了"-"，因此对齐方式为左对齐，与默认情况一样。
%.40d{date}：也是按当前所在地区显示日期和时间，但指定最大宽度为40，当输出信息多于40个字符时会将左边多出的字符截掉。此外，最大宽度只支持默认的左对齐方式，而不支持右对齐。
0.40d{date}：如果输出信息少于30个字符就补空格并右对齐，如果多于40个字符，就将左边多出的字符截掉。
%-30.40d{date}：如果输出信息少于30个字符就补空格并左对齐，如果多于40个字符，就将左边多出的字符截掉。
芦苇 2007-11-09 13:25
jsp 标签库
2007-06-20 13:50
与struts结合使用最出名的一个tag主要是显示表格数据很漂亮、完善。
用来在web上显示复杂图形报表的一个jsp tag。
当一个复杂的操作可以加载比较长的时间时，用这个tag。
dbforms!它是一个基于 java (servlet,jsp/taglib)的快速应用程序开发环境，可以帮助开发人员快速建造基于web的数据库应用程序。
jakarta taglibs 是为jsp定制标签库和相关的项目提供的一个开源仓库，如 taglibraryvalidator类，和对页面生成工具的扩展来支持标签库。jakarta taglibs 也包括了对jsp standard tag library (jstl)的参考实现。这个实现基于项目标准。目前，在jakarta taglibs 中没有其它标签库代表了java community process (jcp) 标准。
ldap标签库为jsp程序员和web页面设计者提供了最容易的方法来执行任意的ldap操作。
webjmx标签库项目可以控制你的jmx 接口。webjmx 这个标签库项目的目的是生成一个jsp标签库，可以让有技巧的jsp开发人员为jmx生成一个可定制的、规范的、基于web的界面。
jpivot - 是一个jsp 自定制的标签库，可以绘制一个olap表格和图表。用户可以执行典型的olap导航，如下钻，切片和方块。它使用mondrian 作为其olap服务器。
jsp tree tag是一个显示树型结构jsp标签，它只把需要显示的部分送到客户浏览器。
该标记库和 google 有关。使用该标记库，利用 google 为你的网站提供网站查询，并且可以直接在你的网页里面显示搜查的结果。
tabletag是类似于datagrid的jsp标签库。通过java.util.list填充数据。
uitags利用这个开源自定义标签可以很容易开发出一个友好的用户界面。
valuelist利用这个标签可以进行数据过滤，排序，分页。而且界面挺漂亮的。
jce taglib把jce（java cryptographic extensions）包装成taglib并且包含了el函数。使用这个标签能够为jsp应用程序加强安全性。
prize tags是一个集许多功能于一身的jsp标签库。其中最受欢迎的tree tag，这个tag可以为不同节点指定不同的图标，而且可以服务端可以监控客户端节点的展开，关闭，选中与未选中等事件。除了tree tag还有日历tag,icon tag,alternate tag ,template tag 等其它的功能。
struts -layout是一个用在struts的标签库.这个强大的标签库可以用来显示面板(panels),输入框,表格,treeviews, sortable lists,datagrids,popups,日历等.使用这些标签可以不用写html代码,甚至可以不用懂得html.这个项目还提供一个 eclipse下的插件帮助使用struts和struts-layout来开发jsp页面.以下是一张例图:
jimagetaglib是一个用在j2ee web应用程序的java标签库.它用来在服务端生成与处理图片然后再反馈到jsp页面.可以过滤(filtering)图片,调整图片文件大小,生成条形码等.
uitags是一个开源的jsp custom-tag库.它让开发友好的用户界面变得简单.
awtaglib是一个jsp标签可用于创建网格(grid)控件.它还提供一些额外的功能可以把网格中的数据导出为xls,pdf和csv(利用jasperreports来实现)并能与struts框架相结合.
extremetable是一个可扩展的用于以表格的形式来显示数据的一组jsp标签库.
这是一个可用来开发多页选项板（tabbed pane）的简单标签。以下是一个demo:
foo is cool!
jpa-taglib为使用java persistence api提供一个jsp标签库。这个标签库定义了六个标签涉及一些普通的数据存取任务。
em, 获取一个entitymanager
tx, 事务定界
persist, 通过当前entitymanager来把对象持久化
remove, 从数据存储中移除去对象
find, 通过一个给定的主关键字来查找对象
refresh, 刷新对象的内容
这组jsp标签包含了一些常用的ui构件（wizzard, tree, progressbar, list, combobox和titled panel）。ajax技术也被尽可能地运用到其中。
formview 标签能够根据状态(新增,查看,修改,删除操作)和表单的属性(最大长度,是不是date或是否必填等)来控制form中的表单到底是要修饰成read- only或还是read-write。因此利用formview我们就可以在同一jsp页面中很简洁得实现crud(create,update, read,delete)操作而无需多个jsp页面或复杂的条件判断。它看起来类似于struts-layout,但是formview不仅能够控制简单 的html input而且还能够控制任何能生成html input的jsp标签(如struts的html:text标签，也可以是自己开发的标签)。
利用google:maps jsp标签库就能够在你的web站点上实现googlemaps的所有功能而且不需要javascript或ajax编程。它还能够与jstl相结合生成数据库驱动的动态maps。
dt-source这个标签库让displaytag标签能够在jsp页面中直接调用数据源(hibernate,jdbc等)中的数据。dt-source基于spring框架开发。
micronova yuzu开源基于el的jsp标签库。这是一个增强的jstl(兼容jsp1.2与jsp 2.0)。
jscontrolstags 这个jsp标签库提供了一些基于ajax（prototype.js/scriptaculous.js）技术的web ui控件（autocomplete，slider/ajaxslider，treeview，swap）。jscontrolstags利用json来 在服务器与客户端之间传递信息。
pack: tag是一个用于压缩静态资源的jsp标签库。它能够压缩javascript或css并缓存到内存或文件中。压缩算法可针对不同资源类型进行扩展。扩展 使用策略设计模式实现。利用pack:tag压缩静态资源：能够减少带宽；加速客户端装载时间；混淆内容和资源名称。解决javascript文件浏览器 缓存问题(将hashcode成新的资源名称)。
|
芦苇 2007-10-29 08:35
@qq745224544
不客气,这是转别人的文章,我同样感激原创作者!
芦苇 2007-10-16 11:28
关键字: grasp java 软件模式
|
当我们分析清楚客户需求设计出用例模型以后，当我们分析清楚客户的业务环境制作出领域模型以后，当我们综合用例模型、领域模型和我们的聪明才智设计出一个又一个的类和它们各自的方法以后，当就在一切都准备就绪只欠东风的关键时刻，一个对象发出了撕心裂肺的怒吼——谁来创建我？！！！一个对象，不管拥有多么强大的功能，不管进行了多么精巧的设计，如果不能被创建，就如同韩信不能做将军，孙膑不能当军师，勾践不能回越国，刘备不能得荆州，一切一切的雄才武略都如废纸一张。既然“创建”对于对象如此重要，我们就来好好探讨一下grasp3. 当我们完成了用例模型、领域模型、对象分析的设计，初步完成了对象设计和职责分配的工作，开始进一步细化的时候，一个我们不得不考虑的问题就摆在我们的面前——谁来创建这些对象？也许现在的你会觉得好笑，这也是问题吗？在软件实际开发过程中，谁需要使用某个对象，就去创建它就行了，有什么好讨论的。但是，我不得不说的是，如果你只是漫不经心地想要随意开发一套软件系统，仅仅是完成自己工作而已，你完全不用考虑创建对象的问题。然而如果你希望开发一套高质量的、低耦合的、封装性和复用性高的软件系统，你必须得认真考虑这个问题。为什么呢？因为系统中如果一个对象a那么为了降低系统耦合，提高系统的清晰度、封装性和可复用性，应该有一些通用的原则，以用于对象职责分配中，关于“创建对象”这类职责的分配。这些原则的描述就在grasp1） 创建者模式的描述
如果以下条件之一为真（越多越好），则将创建类a如果有以上多个选项适用，通常首先条件1
2） 何时使用
在理解创建者模式的时候，我认为一个首先必须理解的问题是，在软件项目的整个过程中，它应该是在什么阶段使用。一个网友曾经发帖问我，他不清楚grasp3） 为什么
我们做事往往有个习惯，凡事问个为什么。前面我提到，使用创建者模式的主要目的是可以降低系统的耦合。那么，我们在使用创建者模式的这几个建议的时候是如何降低耦合的呢？这一直是困扰了我很久的一个疑问，craig larman创建者模式告诉我们，如果系统中存在包含者容纳被包含者，或整体聚集部分，则包含者往往是被包含者的最佳创建者，整体往往是部分的最佳创建者。为什么呢？首先，这样的设计易于理解，可读性强。为什么这么说呢，我们用我们常见的单据与单据明细来说明吧。一张单据有多条单据明细，这些单据明细聚集于单据中，是单据的一个部分。对于某张单据，我们只有去填写这张单据，才会去填写它的明细。同样，我们要查看和修改这张单据的明细，首先肯定是找到这张单据。以上这些是我们在实际生活中大家都认同的管理单据的方式。grasp尽管包含者往往是被包含者的最佳创建者，整体往往是部分的最佳创建者，但是在一个软件系统中，并不是所有类都有它的包含者或者整体。如果没有，谁应当创建它呢？记录者当然是另一个可以考虑的人选。仓库管理员管理进出库是erp如果我们正在设计的软件类也没有记录者，这可如何是好？具有创建这个类所需数据的那个类可以考虑，那个类就是信息专家（什么是“信息专家”，我会在以后对信息专家模式的文章中详细描述）。在我们的设计过程中，很多类的创建是需要一些初始化数据的。最典型的就是我们的vo如果以上方法还不行，那我们就只有找使用者了。寻找使用者是我们创建类最常用的一种方法，但它的缺点也非常明显。正如前面我描述的，我们系统中对某个软件类的使用可能分布到系统的各个角落。当我们因为某个需求需要修改这个类的时候，我们根本不知道谁在使用它。正因为如此，这样的修改变得如梦魇一般，不断地搜索，不断地修改。我们前面说过，合理的软件构造是为了使我们的变更代价最小，而这样的变更将使我们的代价太大了，也许一个不经意的变更错误将造成我们的系统中一个意想不到的地方发生异常。故我们变更后测试的代价也就因此而增大。总之，寻找使用者作为创建者是我们业务分析阶段最后的终极选择。
4） 创建者模式是原则，不是准则
“创建者模式是原则，不是准则”难道“原则”和“准则”还有不同吗？当然。创建者模式是原则，所以我们在业务分析阶段应当尽量遵守。但创建者模式不是准则，因为并非我们的所有软件类都必须遵守。为什么这么说呢？随着项目的进行，我们的分析设计就不再停留在业务的分析上，各种具体的框架和技术将不断引进项目中，这时对象的创建就不一定符合创建者模式。比如，为了提高系统的性能和可维护性、更好地处理对象的创建与回收等复杂的问题，我们常常把对象的创建交给工厂，如spring
总之，合理地创建对象可以有效的提供可读性、降低耦合度、提高系统的封装性和可移植性，我们应当引起重视。
|
芦苇 2007-10-16 11:27
关键字: 高内聚 java 软件工程 软件模式
在上一章中我聊了聊低耦合，今天我想再聊聊与低耦合休戚相关、grasp的另一个重要的模式：高内聚。
2. 高内聚是另一个普遍用来评判软件设计质量的标准。内聚，更为专业的说法叫功能内聚，是对软件系统中元素职责相关性和集中度的度量。如果元素具有高度相关的职责，除了这些职责内的任务，没有其它过多的工作，那么该元素就具有高内聚性，反之则为低内聚性。高内聚要求软件系统中的各个元素具有较高的协作性，因为在我们在完成软件需求中的一个功能，可能需要做各种事情，但是具有高内聚性的一个元素，只完成它职责内的事情，而把那些不在它职责内的事情拿去请求别人来完成。这就好像，如果我是一个项目经理，我的职责是监控和协调我的项目各个阶段的工作。当我的项目进入需求分析阶段，我会请求需求分析员来完成；当我的项目进入开发阶段，我会请求软件开发人员来完成；当我的项目需要测试的时候，我会请求测试人员。。。。。。如果我参与了开发，我就不是一个高内聚的元素，因为开发不是我的职责。
我们的项目为什么要高内聚呢？我觉得可以从可读性、复用性、可维护性和易变更性四个方面来理解。
1一个人写文章、讲事情，条理清晰才能易于理解，这同样发生在读写软件代码上。如果一堆代码写得一团乱麻，东一个跳转西一个调用，读它的人会感觉非常头疼。这种事情也许一直在写程序的你我都曾经有过经历。如果一段程序条理非常清晰，每个类通过名称或说明都能清楚明白它的意义，类的每个属性、函数也都是易于理解的它所应当完成的任务和行为，这段程序的可读性必然提高。在软件产业越来越密集，软件产业中开发人员协作越来越紧密、分工越来越细的今天，软件可读性的要求相信也越来越为人们所重视。
2在软件开发中，最低等级的复用是代码拷贝，然后是函数的复用、对象的复用、组件的复用。软件开发中最懒的人是最聪明的人，他们总是想到复用。在代码编写的时候突然发现某个功能是曾经实现过的功能，直接把它拷贝过来就ok在前面《》中我提到，我们现在的软件是在不断变更的，这种变更不仅来自于我们的客户，更来自于我们的市场。如果我们的软件通过变更能及时适应我们的市场需求，我们就可以在市场竞争中获胜。如何能及时变更以适应我们的市场呢，就是通过调整软件的结构，使我们每次的变更付出的代价最小，耗费的人力最小，这种变更才最快最经济。高内聚的软件，每个系统、模块、类的任务都高度相关，就使每一次的变更涉及的范围缩小到最小。比如评审表发生了变更，只会与评审表对象有关，我们不会去更改其它的对象。如果我们能做到这一点，我们的系统当然是可维护性好、易变更性好的系统。
那么，我们如何做到高内聚呢？就拿前面我提到的评审项目举例。我现在要为“评审表”对象编写一段填写并保存评审表的代码。评审表对象的职责是更新和查询评审表的数据，但是在显示一个要填写的评审表的时候，我需要显示该评审计划的名称、该评审计划有哪些评审对象需要评审。现在我如何编写显示一个要填写的评审表的代码？我在评审表对象的这个相应的函数中编写一段查询评审计划和评审对象的代码吗？假如你这样做了，你的代码就不是高内聚的，因为查询评审计划和评审对象的数据不是它的职责。正确的方法应当去请求“评审计划”对象和“评审对象”对象来完成这些工作，而“评审表”对象只是获取其结果。
另外，如果一个对象要完成一个虽然在自己职责范围内，但过程非常复杂的任务时，也应当将该任务分解成数个功能相对独立的子函数来完成。我曾经看见一个朋友写的数百行的一个函数，让人读起来非常费劲。同时这样的函数中一些相对独立的代码，本可以复用到其它代码中，也变成了不可能。所以我给大家的建议是，不要写太长的函数，超过一百行就可以考虑将一些功能分解出去。
与“低耦合”一样，高内聚也不是一个绝对，而是一个相对的指标，应当适当而不能过度。正如我们在现实生活中，如果在一个十来人的小公司，每个人的分工可能会粗一些，所分配的职责会广一些杂一些，因为其总体的任务少；而如果在一个一两百人的大公司，每个人的分工会细一些，所分配的任务会更加专一些，因为总体任务多，更需要专业化的分工来提高效率。软件开发也是一样，如果“评审计划”对象完成的业务功能少，并且不复杂，它完全可以代理它的子表“评审对象”和“评审者”的管理。但是“评审计划”对象需要完成的“对评审计划表的管理”这个基本职责包含的业务功能繁多或者复杂，它就应当将“对评审对象表的管理”交给“评审对象”对象，将“对评审者表的管理”交给“评审者”对象。同样，高内聚的可维护性好、易变更性好只能是一个相对的指标。如果一个变更的确是大范围的变更，你永远不可能通过内聚就不进行大范围的变更了。同时内聚也是要付出代价的，所以你也不必要去为了一个不太可能的变更去进行过度设计，应当掌握一个度。过度的内聚必将增加系统中元素之间的依赖，提高耦合度。所以“高内聚”与“低耦合”是矛盾的，必须权衡利弊，综合地去处理。综上所述，“高内聚”给软件项目带来的优点是：可读性强、易维护和变更、支持低耦合、移植和重用性强。
|
芦苇 2007-10-16 11:27
一个优秀软件开发人员的必修课：grasp（2）低耦合
| 我偶然在google或yahoo这样的搜索引擎搜索grasp发现，除了国外的网站，国内网站多介绍和讨论gof而很少介绍grasp，即使这少量的文章也讲解非常粗略。个人认为作为优秀的开发人员，理解grasp比gof更重要，故写此文章。前面我在
| aaa1.jpg |
| 描述: |
|
| 文件大小: |
21 kb |
| 看过的: |
文件被下载或查看 676 次 |
|
最后更新：2007-01-31 08:47
14:51 | | 浏览 (4062) | (8) | | | |
|
芦苇 2007-10-16 11:17
程序版本：
subversion：1.3.2（）
smartsvn：2.0.6（）本地下载：
安装过程：
1、安装subversion。这个过程很简单，默认安装就可以了，没什么可说的。
2、创建repository（可以理解为代码仓库，其实除了放代码，其他的也可以放的^_^）：
通过cmd进入命令行模式，输入下列命令，在d:\subversionworkspace\pub这个目录下建立repository：
svnadmin create --fs-type fsfs d:\subversionworkspace\pub
注：之所以选择fsfs格式，参考下面的文档中的相关资料
相关文档资料：
$ svnadmin create --fs-type fsfs /path/to/repos
$ svnadmin create --fs-type bdb /path/to/other/repos
warning
do not create a berkeley db repository on a network share—it cannot exist on a remote filesystem such as nfs, afs, or windows smb. berkeley db requires that the underlying filesystem implement strict posix locking semantics, and more importantly, the ability to map files directly into process memory. almost no network filesystems provide these features. if you attempt to use berkeley db on a network share, the results are unpredictable—you may see mysterious errors right away, or it may be months before you discover that your repository database is subtly corrupted.
if you need multiple computers to access the repository, you create an fsfs repository on the network share, not a berkeley db repository. or better yet, set up a real server process (such as apache or svnserve), store the repository on a local filesystem which the server can access, and make the repository available over a network. chapter 6, server configuration covers this process in detail.
3、添加用户并设置权限。没有做详细研究，请直接参考下面的资料：
转自：
独立运行的subversion权限设置很简单，首先打开snvserve.conf，去掉下面一行的注释
authz-db = authz
然后打开同一目录下的authz这个文件，这个文件便是整个权限控制的核心，先来看一个例子：
[groups]
dev-group = liudong,xfliang
design-group = newidea
[/]
@dev-group = rw
@design-group = r
* =
[/doc]
@design-group = rw
[/webapp]
@design-group = rw
接下来我给大家解释一下这个文件，相信就可以明白subversion如何来做权限控制的了。
首先我定义了两个组，一个开发组(dev-group)，一个设计组(design-group)，接下来我让dev-group对整个目录有读写的权限，而design-group只有读权限。但是接下来的两个子目录design-group就有读写权限，也就是说设计组可以读取整个项目，但只能修改doc以及webapp这两个子目录。
*= 这行表示其他人不能读写。当然也可以直接指定某个用户，例如我想让liudong这个用户可以读写webapp目录，那设置如下：
[/webapp]
@design-group = rw
liudong = rw
另外有一点注意的是，修改这个文件不需要重新启动svn服务，这点太棒了。
下面是详细的说明subversion自带的authz样例中的注释
### this file is an example authorization file for svnserve.
### its format is identical to that of mod_authz_svn authorization
### files.
### as shown below each section defines authorizations for the path and
### (optional) repository specified by the section name.
### the authorizations follow. an authorization line can refer to a
### single user, to a group of users defined in a special [groups]
### section, or to anyone using the '*' wildcard. each definition can
### grant read ('r') access, read-write ('rw') access, or no access
### ('').
4、将subversion注册为系统。将svnservise拷贝到subversion的安装目录下的bin目录（我这里为：c:\program files\subversion\bin）。然后在cmd中转到刚刚那个目录，运行下列命令：
svnserve -d -r d:\subversionworkspace\
注：以下是svnserve的命令选项
svnserve [选项]
有效选项：
-d [--daemon] : 后台模式
--listen-port 参数 : 监听端口（后台模式）
--listen-host 参数 : 监听主机名或ip地址（后台模式）
--foreground : 在前台运行（调试时有用）
-h [--help] : 显示这个帮助
--version : 显示版本信息
-i [--inetd] : inetd 模式
-r [--root] 参数 : 服务根目录
-r [--read-only] : force read only, overriding repository config file
-t [--tunnel] : 隧道模式
--tunnel-user 参数 : 隧道用户名（模式是当前用户uid的名字）
-x [--listen-once] : 监听一次（调试时有用）
5、用smartsvn连接刚刚建好的服务器
svnservise：将subversion注册为系统服务的东东。本地下载：
tortoisesvn：1.4.0 rc1（）
安装环境：
windows xp－sp2－en
trackback: http://tb.blog.csdn.net/trackback.aspx?postid=1495108
芦苇 2007-10-16 11:16
1. 配置环境
windows 2003 server with sp1
apache http server v2.0.55
subversion v1.4.2
2. 安裝 apache http server
将安装目录修改为c:\apache group
默认是安装到c:\program files\apache group目录下
安装后的目录结构如下：
c:\apache group\apache2\bin\
c:\apache group\apache2\conf\
......
3. 安裝 subversion
这里使用zip包，解压到c盘，然后将c:\svn-win32-1.4.2\bin添加环境变量path中。
解压后的目录结构如下：
c:\svn-win32-1.4.2\bin\
c:\svn-win32-1.4.2\iconv\
......
l 将c:\svn-win32-1.4.2\bin目录下的mod_dav_svn.so和mod_authz_svn.so复制到c:\apache group\apache2\modules目录下。
l 将c:\svn-win32-1.4.2\bin目录下的所有dll文件复制到c:\apache group\apache2\bin目录下。注意在复制dll文件时最好停掉apache。
l 用文本编辑器打开c:\apache group\apache2\conf\httpd.conf文件找到以下两行
#loadmodule dav_module modules/mod_dav.so
#loadmodule dav_fs_module modules/mod_dav_fs.so
去掉前面的#，然后所有loadmodule的后面添加下面两行
loadmodule dav_svn_module modules/mod_dav_svn.so
loadmodule authz_svn_module modules/mod_authz_svn.so
然后重起apache
4. 建库
假设所有库的根目录是f:\svn，并且要建一个名为testrepos的库，打开dos窗口，进入到f:\svn目录下，然后输入svnadmin create f:\svn\testrepos
命令执行完后f:\svn\testrepos目录下会生成一些目录和文件。然后在c:\apache group\apache2\conf\httpd.conf文件的最后添加下面内容，并重起apache
dav svn
svnparentpath f:\svn
5. 测试
打开dos窗口，进入一个临时目录f:\temp下
svn co http://localhost/svn/testrepos
正确执行后会显示"checked out revision 0."的信息。
6. 导入
在一个临时文件夹(比如c:\temp)下建立如目录
trunk
branches
tags
在dos命令行下进入c:\temp目录，然后执行
svn import . http://localhost/svn/testrepos -m "initial repository"
执行成功的话会提示提交后的修订版本为1。
7. 关于库的建立
建议为会每一个项目建立一个库，例如：
f:\svn\project1
f:\svn\project2
再为每个库建立如下结构(subversion官方手册建议的目录结构)
f:\svn\project1\trunk 这个目录用来存放正在进行开发的项目代码
f:\svn\project1\branches 这个目录用来存放正在开发中的版本分支
f:\svn\project1\tags 这个目录用来存放不再变动的分支
trackback: http://tb.blog.csdn.net/trackback.aspx?postid=1495115
芦苇 2007-10-08 13:53
web-inf/classes/hibernate.properties
hibernate.hbm2ddl.auto=create
hibernate.hbm2ddl.auto=create
web-inf/classes/import.sql
源码复制打印
insert into mytable(id,name) values(1,'name1');
insert into mytable(id,name) values(2,'name2');
insert into mytable(id,name) values(3,'name3');
insert into mytable(id,name) values(1,'name1');
insert into mytable(id,name) values(2,'name2');
insert into mytable(id,name) values(3,'name3');
当web运行时,hibernate会自动重新生成表结构并插入import.sql里的那三条记录.
芦苇 2007-10-08 13:53
在hibernate3中可以自动建数据库及自动导入数据.在hibernate.properties文件里加入：
hibernate.hbm2ddl.auto=create
就可以自动建表结构
设hibernate.hbm2ddl.auto为update/create-drop/create其中一种都会改变表结构，如果同时在classpath中写一个/import.sql文件,里包含了数据内容的insert等，那么hibernate3在启动时就会执行import.sql的内容。
芦苇 2007-07-24 15:59
sequence是一种方法。也可以用用indentity列
create table table (col1 int,
col2 double,
col3 int not null generated always as identity
(start with 100, increment by 5))
芦苇 2007-07-24 15:52
我自己曾用到的:
--建触发器
--修改登录人信息触发
create trigger db2admin.t_userlogin_upd after update on db2admin.user_login referencing new as n old as o for each row
begin atomic
declare temp_ibmsnap_commitseq bigint;
if ((n.work_id <> o.work_id) or (n.user_login_id <> o.user_login_id) or (n.current_password <> o.current_password)) then
set temp_ibmsnap_commitseq = nextval for db2admin.seq_name;
insert into db2admin.ccd_user_ldap values (temp_ibmsnap_commitseq, 0, 'u', n.party_id, n.user_login_id , n.current_password , 'clerk_name' , n.work_id , '1' );
update db2admin.ccd_user_ldap set clerk_name = (select clerk_name from clerk where party_id =n.party_id) where ibmsnap_commitseq = temp_ibmsnap_commitseq;
end if;
end
--新增登录人信息触发
create trigger db2admin.t_userlogin_ins after insert on db2admin.user_login referencing new as n for each row
begin atomic
declare temp_ibmsnap_commitseq bigint;
set temp_ibmsnap_commitseq = nextval for db2admin.seq_name;
insert into db2admin.ccd_user_ldap values (temp_ibmsnap_commitseq, 0, 'i', n.party_id, n.user_login_id , n.current_password , 'clerk_name' , null , '1');
update db2admin.ccd_user_ldap set clerk_name = (select clerk_name from clerk where party_id =n.party_id) where ibmsnap_commitseq = temp_ibmsnap_commitseq;
end
--修改登录人姓名或状态触发
create trigger db2admin.t_userinfo_upd after update on db2admin.clerk referencing new as n old as o for each row
begin atomic
declare temp_ibmsnap_commitseq bigint;
if ((n.clerk_name <> o.clerk_name) or (n.clerk_status <> o.clerk_status)) then
set temp_ibmsnap_commitseq = nextval for db2admin.seq_name;
insert into db2admin.ccd_user_ldap values (temp_ibmsnap_commitseq, 0, 'u', n.party_id, 'user_login_id' , 'current_password' , n.clerk_name , 'work_id', '0' );
update db2admin.ccd_user_ldap set user_login_id = (select user_login_id from user_login where party_id =n.party_id),current_password=(select current_password from user_login where party_id =n.party_id),work_id=(select work_id from user_login where party_id =n.party_id) where ibmsnap_commitseq = temp_ibmsnap_commitseq;
end if;
end
--删除触发器
drop trigger db2admin.t_userlogin_ins;
drop trigger db2admin.t_userlogin_upd;
drop trigger db2admin.t_userinfo_upd;
--创建一个sequence
create sequence seq_name start with 1 increment by 1
--删除sequence
drop sequence seq_name
芦苇 2006-11-24 15:58
有一个小bug
public chineseera() {
int iyear = 1981;
}
应该是
public chineseera(){
iyear = 1981;
}
芦苇 2006-11-24 15:34
aspjpeg添加水印完整方法
aspjpeg添加水印完整方法
用aspjpeg组件制作图片的缩略图和加水印
aspjpeg是persits出品的共享软件，试用期为30天，您可以在这里下载：。最新版本号是1.3
aspjpeg是一款功能相当强大的图象处理组件，用它可以轻松地做出图片的缩略图和为图片加上水印功能。下面简单介绍一下使用方法：
您先要执行下载得到的exe文件，安装该组件
1、为图片制作缩略图
<% \\\' 建立实例
dim jpeg,path
set jpeg = server.createobject("persits.jpeg")
\\\' 图片所在位置
path = server.mappath("images") & "\\\\clock.jpg"
\\\' 打开
jpeg.open path
\\\' 设置缩略图大小（这里比例设定为50%）
jpeg.width = jpeg.originalwidth / 2
jpeg.height = jpeg.originalheight / 2
\\\' 保存缩略图到指定文件夹下
jpeg.save server.mappath("images") & "\\\\clock_small.jpg"
\\\' 注销实例
set jpeg = nothing
%>
2、为图片加入水印功能
<%
dim jpeg
\\\' 建立实例
set jpeg = server.createobject("persits.jpeg")
\\\' 打开目标图片
jpeg.open server.mappath("images/dodge_viper.jpg")
\\\' 添加文字水印
jpeg.canvas.font.color = &hff0000\\\' 红色
jpeg.canvas.font.family = "宋体"
jpeg.canvas.font.bold = true
jpeg.canvas.print 10, 10, "凯发天生赢家一触即发官网 copyright (c) cnmaya.org"
\\\' 保存文件
jpeg.save server.mappath("images/dodge_viper_framed.jpg")
\\\' 注销对象
set jpeg = nothing
%>
上次做过图片水印，效果很差，没办法把图片弄成背景透明的，用背景透明gif会自动填充成白色。用去掉某种颜色的功能，图片颜色总是不纯，出来的效果斑斑点点。今天灵机一动，把这两个结合起来，用背景透明的gif，并且抽取水印底色，果然成功了！
ogvbox.canvas.pen.color = &h000000 \\\'// 边框的颜色
ogvbox.canvas.pen.width = 1 \\\'// 边框的粗细
ogvbox.canvas.brush.solid = false \\\'// 图片边框内是否填充颜色
ogvbox.drawimage ogvbox.width-210, ogvbox.height-74, logobox ,0.3,&hffffff \\\'// 加入图片的位置坐标（添加水印图片），我用图片大小减去水印大小，把水印加在右下角。参数顺序为：水平坐标，垂直坐标，水印图片地址，水银透明度，抽取颜色（&h表示16进制）
ogvbox.canvas.bar 0, 0, ogvbox.width, ogvbox.height \\\'// 图片边框线的位置坐标和大小
ogvbox.save server.mappath(imagename) \\\'// 生成文件
\'//------pollener.com aspjpeg组件的预览和水印生成------开始------
\'创建预览图片:call createview(原始文件的路径,预览文件名及路径)
sub createview(imagename,tempfilename)
\'定义变量。
dim previewimagefoldername
dim ogvbox,objfont
dim logobox,logopath
logopath = server.mappath("images") & "\\shuiyin.gif" \'//加入图片所在路径及文件名(我的是论坛\\images\\shuiyin.gif)。
select case upload_viewtype
case 0
\'---------------------createpreviewimage---------------
set ogvbox = server.createobject("createpreviewimage.cgvbox")
ogvbox.setsavepreviewimagepath=server.mappath(tempfilename) \'预览图存放路径。
ogvbox.setpreviewimagesize =setpreviewimagesize \'预览图宽度。
ogvbox.setimagefile = trim(server.mappath(imagename)) \'imagename原始文件的物理路径。
\'创建预览图的文件。
if ogvbox.doimageprocess=false then
response.write "生成预览图错误:"& ogvbox.geterrstring
end if
case 1
\'---------------------aspjpegv1.2---------------
set logobox = server.createobject("persits.jpeg")
\'//建议不要图片和文字水印同时使用，本代码为使用图片水印。
logobox.open logopath \'//读取添加的图片。
\'//重新设置图片的大小。
logobox.width = 186 \'//用做水印的图片的宽度值（像素）。
logobox.height = 52 \'//用做水印的图片的高度值（像素）。
\'//添加水印。
set ogvbox = server.createobject("persits.jpeg")
\'//读取要处理的原文件。
ogvbox.open trim(server.mappath(imagename))
if ogvbox.originalwidth f_viewname=""
set ogvbox = nothing
exit sub
else
if imagemode<>"" and fileext<>"gif" then \'//如果将这行改为if imagemode<>"" then则可给上传的gif图片也加上水印，但是那些动画的gif在加了水印以后就只剩第一桢了，根据你的需求酌情处理吧。
\'//关于修改字体及文字颜色的。
\'//ogvbox.canvas.font.color = &h0000ff \'//水印文字的颜色，&h后面输入色彩值。
\'//ogvbox.canvas.font.size = 18 \'//水印文字的大小。
\'//ogvbox.canvas.font.family = "arial" \'//水印文字的字体名称。
\'//ogvbox.canvas.font.shadowcolor = &h000000 \'//水印文字的阴影色彩。
\'//ogvbox.canvas.font.shadowxoffset = 1 \'//水印文字阴影向右偏移的像素值，输入负值则向左偏移。
\'//ogvbox.canvas.font.shadowyoffset = 1 \'//水印文字阴影向下偏移的像素值，输入负值则向右偏移。
\'//ogvbox.canvas.font.quality = 3 \'//水印文字的清晰度，从0～4，变换不是很大，建议用2或3。
\'//ogvbox.canvas.font.bold = true \'//水印文字是否为粗体，true=粗体 false=正常。
\'ogvbox.canvas.print 10, 10, imagemode \'//水印文字的起始坐标（像素）。
ogvbox.canvas.pen.color = &h000000 \'//增加水印后图片的边框色彩。
ogvbox.canvas.pen.width = 1 \'//增加水印后图片的边框宽度。
ogvbox.canvas.brush.solid = false \'//边框内是否填充颜色，你可以试试看值为true时的效果^o^
ogvbox.drawimage ogvbox.width-186, ogvbox.height-52, logobox, 0.5 \'//水印图片的起始坐标，我这里ogvbox.width-186, ogvbox.height-52,表示图片在右下角，因为我的图片宽是186，高是52，所以这样写，你可以根据自己的图片进行调整。0.5是透明度，我这里是半透明，1表示不透明，你也可以试试看0.7或者0.8的效果。
ogvbox.canvas.bar 0, 0, ogvbox.width, ogvbox.height \'//水印可用的范围。我这里表示左上角至右下角，即整张图片的任意为止都可加水印。
ogvbox.save server.mappath(imagename) \'//根据以上参数生成增加水印后的图片文件。
end if
ogvbox.width = imagewidth
ogvbox.height = imageheight
\'ogvbox.height = ogvbox.originalheight*imagewidth\\ogvbox.originalwidth
ogvbox.sharpen 1, 120
ogvbox.save server.mappath(tempfilename) \'//生成增加水印后的图片的预览图片。
end if
set logobox=nothing
\'//------pollener.com aspjpeg组件的预览和水印生成------结束------
芦苇 2006-11-24 15:09
c#的汉字转拼音
///
/// 获取一串汉字的拼音声母
///
/// unicode格式的汉字字符串
/// 拼音声母字符串
public static string convert(string chinese)
{
char[] buffer = new char[chinese.length];
for(int i=0; i {
buffer[i] = convert(chinese[i]);
}
return new string(buffer);
}
///
/// 获取一个汉字的拼音声母
///
/// unicode格式的一个汉字
/// 汉字的声母
public static char convert(char chinese)
{
encoding gb2312 = encoding.getencoding("gb2312");
encoding unicode = encoding.unicode;
// convert the string into a byte[].
byte[] unicodebytes = unicode.getbytes(new char[] {chinese});
// perform the conversion from one encoding to the other.
byte[] asciibytes = encoding.convert(unicode, gb2312, unicodebytes);
// 计算该汉字的gb-2312编码
int n = (int)asciibytes[0]<<8;
n = (int)asciibytes[1];
// 根据汉字区域码获取拼音声母
if (in(0xb0a1,0xb0c4,n)) return 'a';
if (in(0xb0c5,0xb2c0,n)) return 'b';
if (in(0xb2c1,0xb4ed,n)) return 'c';
if (in(0xb4ee,0xb6e9,n)) return 'd';
if (in(0xb6ea,0xb7a1,n)) return 'e';
if (in(0xb7a2,0xb8c0,n)) return 'f';
if (in(0xb8c1,0xb9fd,n)) return 'g';
if (in(0xb9fe,0xbbf6,n)) return 'h';
if (in(0xbbf7,0xbfa5,n)) return 'j';
if (in(0xbfa6,0xc0ab,n)) return 'k';
if (in(0xc0ac,0xc2e7,n)) return 'l';
if (in(0xc2e8,0xc4c2,n)) return 'm';
if (in(0xc4c3,0xc5b5,n)) return 'n';
if (in(0xc5b6,0xc5bd,n)) return 'o';
if (in(0xc5be,0xc6d9,n)) return 'p';
if (in(0xc6da,0xc8ba,n)) return 'q';
if (in(0xc8bb,0xc8f5,n)) return 'r';
if (in(0xc8f6,0xcbf0,n)) return 's';
if (in(0xcbfa,0xcdd9,n)) return 't';
if (in(0xcdda,0xcef3,n)) return 'w';
if (in(0xcef4,0xd188,n)) return 'x';
if (in(0xd1b9,0xd4d0,n)) return 'y';
if (in(0xd4d1,0xd7f9,n)) return 'z';
return '\0';
}
private static bool in(int lp, int hp, int value)
{
return ((value<=hp)&&(value>=lp));
}
转帖自7707(kingfisher)
trackback:
芦苇 2006-11-24 15:08
根据汉字得到拼音的类库（三）
///
/// 存放排好序的汉字－拼音对照字典，格式如下
/// 汉han
/// 字zi
/// 既汉字作为字典的key，拼音作为value
///
private sorteddictionary msortdiction = new sorteddictionary() ;
private static spelllib _instance ;
///
/// 取汉字拼音类的实例
///
///
public static spelllib instance()
{
if (_instance == null)
_instance = new spelllib();
return _instance;
}
///
/// 构造函数
///
private spelllib()
{
buildsortdiction();
}
#region 提供的方法
///
/// 把给定的字转化为拼音
///
/// 要转化的字
/// 字的拼音
///
/// string strcode = spelllib.instance().getcodesbyword('字');
///
/// 如果该字不存在拼音，就返回该字本身
public string getcodebyword(char word)
{
if (msortdiction.containskey(word))
return msortdiction[word];
else
return word.tostring();
}
///
/// 取得字符串第一个字的拼音
///
/// 要转化的字符串
/// 字的拼音
///
/// string strcode = spelllib.instance().getcodesbyword("汉字");
///
/// 如果第一个字不存在拼音，就返回该字本身
public string getcodebyword(string word)
{
if (word == null)
throw new argumentnullexception("word");
if (word.length > 0)
return getcodebyword(word[0]);
else
return null;
}
///
/// 取得一个字符串中所有字的拼音
///
///
///
public string getcodesbyword(string sentence)
{
if (sentence == null)
throw new argumentnullexception("sentence");
bool bladdspace = false;
stringbuilder sbresult = new stringbuilder();
foreach (char chr in sentence)
{
string strcodes = getcodebyword(chr) ;
if (strcodes.length > 1)
{
if (bladdspace == false)
{
sbresult.append(" ");
}
sbresult.append(strcodes);
sbresult.append(" ");
bladdspace = true;
}
else
{
sbresult.append(strcodes);
bladdspace = false;
}
}
return sbresult.tostring();
}
///
/// 构造排序字典对象
///
private void buildsortdiction()
{
// msortdiction.
for (int i = 0; i < this.wordlist.length; i )
{
string value = this.codelist[i];
string strword = wordlist[i];
foreach (char key in strword)
{
if (msortdiction.containskey(key))
{
continue;
}
else
{
msortdiction.add(key, value);
}
}//end foreach
}//end for
}
///
/// 取得给定拼音的声母
///
/// 拼音
/// 声母
/// 如果不存在声母就返回第一个字母，如啊返回a,嗯返回e
public static string getvoicepart(string spell)
{
string strvoicepart = null;
if (spell.length == 1)
{
strvoicepart = spell;
}
else
{
char firstchr = spell[0];
char secondchr = spell[1];
strvoicepart = firstchr.tostring();
if (secondchr.equals('h') || secondchr.equals('h'))
strvoicepart = "h";
switch (strvoicepart.tolower(system.globalization.cultureinfo.currentculture))
{
case "b":
case "p":
case "m":
case "f":
case "d":
case "t":
case "n":
case "l":
case "g":
case "k":
case "h":
case "j":
case "q":
case "x":
case "r":
case "z":
case "c":
case "s":
case "zh":
case "ch":
case "sh":
break;
default:
strvoicepart = firstchr.tostring();
break;
}//end switch
}
return strvoicepart;
}
///
/// 取得给定汉字的声母部分
///
///
///
///
/// string strvoicepart = spelllib.instance().getcodeofvoicepart("字");
///
/// 如果不存在声母就返回第一个字母，如啊返回a,嗯返回e
public string getcodeofvoicepart(string word)
{
return getvoicepart(this.getcodebyword(word));
}
///
/// 取得给定汉字的声母部分
///
///
///
/// 如果不存在声母就返回第一个字母，如啊返回a,嗯返回e
public string getcodeofvoicepart(char word)
{
return getvoicepart(this.getcodebyword(word));
}
#endregion
}//end class
}//end namespace
trackback:
芦苇 2006-11-24 15:06
java将汉字转化成拼音的方法
/** *//**
#############################################################################
# describe 将汉字转化成拼音
# date 2006-7-12
# company flx
# porject java
#############################################################################
*/
import java.util.iterator;
import java.util.linkedhashmap;
import java.util.set;
public class cntospell ...{
private static linkedhashmap spellmap = null;
static ...{
if (spellmap == null) ...{
spellmap = new linkedhashmap(400);
}
initialize();
system.out.println("chinese transfer spell done.");
}
private cntospell() ...{
}
/** *//**
* 获得单个汉字的ascii.
* @param cn char
* 汉字字符
* @return int
* 错误返回 0,否则返回ascii
*/
public static int getcnascii(char cn) ...{
byte[] bytes = (string.valueof(cn)).getbytes();
if (bytes == null || bytes.length > 2 || bytes.length <= 0) ...{ //错误
return 0;
}
if (bytes.length == 1) ...{ //英文字符
return bytes[0];
}
if (bytes.length == 2) ...{ //中文字符
int hightbyte = 256 bytes[0];
int lowbyte = 256 bytes[1];
int ascii = (256 * hightbyte lowbyte) - 256 * 256;
return ascii;
}
return 0; //错误
}
/** *//**
* 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换
* @param cnstr string
* 字符串
* @return string
* 转换成全拼后的字符串
*/
public static string getfullspell(string cnstr) ...{
if (null == cnstr || "".equals(cnstr.trim())) ...{
return cnstr;
}
char[] chars = cnstr.tochararray();
stringbuffer retubuf = new stringbuffer();
for (int i = 0, len = chars.length; i < len; i ) ...{
int ascii = getcnascii(chars[i]);
if (ascii == 0) ...{ //取ascii时出错
retubuf.append(chars[i]);
} else ...{
string spell = getspellbyascii(ascii);
if (spell == null) ...{
retubuf.append(chars[i]);
} else ...{
retubuf.append(spell);
} // end of if spell == null
} // end of if ascii <= -20400
} // end of for
return retubuf.tostring();
}
/** *//**
* 根据ascii码到spellmap中查找对应的拼音
* @param ascii int
* 字符对应的ascii
* @return string
* 拼音,首先判断ascii是否>0&<160,如果是返回对应的字符,
*
否则到spellmap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.
*/
public static string getspellbyascii(int ascii) ...{
if (ascii > 0 && ascii < 160) ...{ //单字符
return string.valueof((char) ascii);
}
if (ascii < -20319 || ascii > -10247) ...{ //不知道的字符
return null;
}
set keyset = spellmap.keyset();
iterator it = keyset.iterator();
string spell0 = null;
;
string spell = null;
int asciirang0 = -20319;
int asciirang;
while (it.hasnext()) ...{
spell = (string) it.next();
object valobj = spellmap.get(spell);
if (valobj instanceof integer) ...{
asciirang = ((integer) valobj).intvalue();
if (ascii >= asciirang0 && ascii < asciirang) ...{ //区间找到
return (spell0 == null) ? spell : spell0;
} else ...{
spell0 = spell;
asciirang0 = asciirang;
}
}
}
return null;
}
private static void initialize() ...{
spellput("a", -20319);
spellput("ai", -20317);
spellput("an", -20304);
spellput("ang", -20295);
spellput("ao", -20292);
spellput("ba", -20283);
spellput("bai", -20265);
spellput("ban", -20257);
spellput("bang", -20242);
spellput("bao", -20230);
spellput("bei", -20051);
spellput("ben", -20036);
spellput("beng", -20032);
spellput("bi", -20026);
spellput("bian", -20002);
spellput("biao", -19990);
spellput("bie", -19986);
spellput("bin", -19982);
spellput("bing", -19976);
spellput("bo", -19805);
spellput("bu", -19784);
spellput("ca", -19775);
spellput("cai", -19774);
spellput("can", -19763);
spellput("cang", -19756);
spellput("cao", -19751);
spellput("ce", -19746);
spellput("ceng", -19741);
spellput("cha", -19739);
spellput("chai", -19728);
spellput("chan", -19725);
spellput("chang", -19715);
spellput("chao", -19540);
spellput("che", -19531);
spellput("chen", -19525);
spellput("cheng", -19515);
spellput("chi", -19500);
spellput("chong", -19484);
spellput("chou", -19479);
spellput("chu", -19467);
spellput("chuai", -19289);
spellput("chuan", -19288);
spellput("chuang", -19281);
spellput("chui", -19275);
spellput("chun", -19270);
spellput("chuo", -19263);
spellput("ci", -19261);
spellput("cong", -19249);
spellput("cou", -19243);
spellput("cu", -19242);
spellput("cuan", -19238);
spellput("cui", -19235);
spellput("cun", -19227);
spellput("cuo", -19224);
spellput("da", -19218);
spellput("dai", -19212);
spellput("dan", -19038);
spellput("dang", -19023);
spellput("dao", -19018);
spellput("de", -19006);
spellput("deng", -19003);
spellput("di", -18996);
spellput("dian", -18977);
spellput("diao", -18961);
spellput("die", -18952);
spellput("ding", -18783);
spellput("diu", -18774);
spellput("dong", -18773);
spellput("dou", -18763);
spellput("du", -18756);
spellput("duan", -18741);
spellput("dui", -18735);
spellput("dun", -18731);
spellput("duo", -18722);
spellput("e", -18710);
spellput("en", -18697);
spellput("er", -18696);
spellput("fa", -18526);
spellput("fan", -18518);
spellput("fang", -18501);
spellput("fei", -18490);
spellput("fen", -18478);
spellput("feng", -18463);
spellput("fo", -18448);
spellput("fou", -18447);
spellput("fu", -18446);
spellput("ga", -18239);
spellput("gai", -18237);
spellput("gan", -18231);
spellput("gang", -18220);
spellput("gao", -18211);
spellput("ge", -18201);
spellput("gei", -18184);
spellput("gen", -18183);
spellput("geng", -18181);
spellput("gong", -18012);
spellput("gou", -17997);
spellput("gu", -17988);
spellput("gua", -17970);
spellput("guai", -17964);
spellput("guan", -17961);
spellput("guang", -17950);
spellput("gui", -17947);
spellput("gun", -17931);
spellput("guo", -17928);
spellput("ha", -17922);
spellput("hai", -17759);
spellput("han", -17752);
spellput("hang", -17733);
spellput("hao", -17730);
spellput("he", -17721);
spellput("hei", -17703);
spellput("hen", -17701);
spellput("heng", -17697);
spellput("hong", -17692);
spellput("hou", -17683);
spellput("hu", -17676);
spellput("hua", -17496);
spellput("huai", -17487);
spellput("huan", -17482);
spellput("huang", -17468);
spellput("hui", -17454);
spellput("hun", -17433);
spellput("huo", -17427);
spellput("ji", -17417);
spellput("jia", -17202);
spellput("jian", -17185);
spellput("jiang", -16983);
spellput("jiao", -16970);
spellput("jie", -16942);
spellput("jin", -16915);
spellput("jing", -16733);
spellput("jiong", -16708);
spellput("jiu", -16706);
spellput("ju", -16689);
spellput("juan", -16664);
spellput("jue", -16657);
spellput("jun", -16647);
spellput("ka", -16474);
spellput("kai", -16470);
spellput("kan", -16465);
spellput("kang", -16459);
spellput("kao", -16452);
spellput("ke", -16448);
spellput("ken", -16433);
spellput("keng", -16429);
spellput("kong", -16427);
spellput("kou", -16423);
spellput("ku", -16419);
spellput("kua", -16412);
spellput("kuai", -16407);
spellput("kuan", -16403);
spellput("kuang", -16401);
spellput("kui", -16393);
spellput("kun", -16220);
spellput("kuo", -16216);
spellput("la", -16212);
spellput("lai", -16205);
spellput("lan", -16202);
spellput("lang", -16187);
spellput("lao", -16180);
spellput("le", -16171);
spellput("lei", -16169);
spellput("leng", -16158);
spellput("li", -16155);
spellput("lia", -15959);
spellput("lian", -15958);
spellput("liang", -15944);
spellput("liao", -15933);
spellput("lie", -15920);
spellput("lin", -15915);
spellput("ling", -15903);
spellput("liu", -15889);
spellput("long", -15878);
spellput("lou", -15707);
spellput("lu", -15701);
spellput("lv", -15681);
spellput("luan", -15667);
spellput("lue", -15661);
spellput("lun", -15659);
spellput("luo", -15652);
spellput("ma", -15640);
spellput("mai", -15631);
spellput("man", -15625);
spellput("mang", -15454);
spellput("mao", -15448);
spellput("me", -15436);
spellput("mei", -15435);
spellput("men", -15419);
spellput("meng", -15416);
spellput("mi", -15408);
spellput("mian", -15394);
spellput("miao", -15385);
spellput("mie", -15377);
spellput("min", -15375);
spellput("ming", -15369);
spellput("miu", -15363);
spellput("mo", -15362);
spellput("mou", -15183);
spellput("mu", -15180);
spellput("na", -15165);
spellput("nai", -15158);
spellput("nan", -15153);
spellput("nang", -15150);
spellput("nao", -15149);
spellput("ne", -15144);
spellput("nei", -15143);
spellput("nen", -15141);
spellput("neng", -15140);
spellput("ni", -15139);
spellput("nian", -15128);
spellput("niang", -15121);
spellput("niao", -15119);
spellput("nie", -15117);
spellput("nin", -15110);
spellput("ning", -15109);
spellput("niu", -14941);
spellput("nong", -14937);
spellput("nu", -14933);
spellput("nv", -14930);
spellput("nuan", -14929);
spellput("nue", -14928);
spellput("nuo", -14926);
spellput("o", -14922);
spellput("ou", -14921);
spellput("pa", -14914);
spellput("pai", -14908);
spellput("pan", -14902);
spellput("pang", -14894);
spellput("pao", -14889);
spellput("pei", -14882);
spellput("pen", -14873);
spellput("peng", -14871);
spellput("pi", -14857);
spellput("pian", -14678);
spellput("piao", -14674);
spellput("pie", -14670);
spellput("pin", -14668);
spellput("ping", -14663);
spellput("po", -14654);
spellput("pu", -14645);
spellput("qi", -14630);
spellput("qia", -14594);
spellput("qian", -14429);
spellput("qiang", -14407);
spellput("qiao", -14399);
spellput("qie", -14384);
spellput("qin", -14379);
spellput("qing", -14368);
spellput("qiong", -14355);
spellput("qiu", -14353);
spellput("qu", -14345);
spellput("quan", -14170);
spellput("que", -14159);
spellput("qun", -14151);
spellput("ran", -14149);
spellput("rang", -14145);
spellput("rao", -14140);
spellput("re", -14137);
spellput("ren", -14135);
spellput("reng", -14125);
spellput("ri", -14123);
spellput("rong", -14122);
spellput("rou", -14112);
spellput("ru", -14109);
spellput("ruan", -14099);
spellput("rui", -14097);
spellput("run", -14094);
spellput("ruo", -14092);
spellput("sa", -14090);
spellput("sai", -14087);
spellput("san", -14083);
spellput("sang", -13917);
spellput("sao", -13914);
spellput("se", -13910);
spellput("sen", -13907);
spellput("seng", -13906);
spellput("sha", -13905);
spellput("shai", -13896);
spellput("shan", -13894);
spellput("shang", -13878);
spellput("shao", -13870);
spellput("she", -13859);
spellput("shen", -13847);
spellput("sheng", -13831);
spellput("shi", -13658);
spellput("shou", -13611);
spellput("shu", -13601);
spellput("shua", -13406);
spellput("shuai", -13404);
spellput("shuan", -13400);
spellput("shuang", -13398);
spellput("shui", -13395);
spellput("shun", -13391);
spellput("shuo", -13387);
spellput("si", -13383);
spellput("song", -13367);
spellput("sou", -13359);
spellput("su", -13356);
spellput("suan", -13343);
spellput("sui", -13340);
spellput("sun", -13329);
spellput("suo", -13326);
spellput("ta", -13318);
spellput("tai", -13147);
spellput("tan", -13138);
spellput("tang", -13120);
spellput("tao", -13107);
spellput("te", -13096);
spellput("teng", -13095);
spellput("ti", -13091);
spellput("tian", -13076);
spellput("tiao", -13068);
spellput("tie", -13063);
spellput("ting", -13060);
spellput("tong", -12888);
spellput("tou", -12875);
spellput("tu", -12871);
spellput("tuan", -12860);
spellput("tui", -12858);
spellput("tun", -12852);
spellput("tuo", -12849);
spellput("wa", -12838);
spellput("wai", -12831);
spellput("wan", -12829);
spellput("wang", -12812);
spellput("wei", -12802);
spellput("wen", -12607);
spellput("weng", -12597);
spellput("wo", -12594);
spellput("wu", -12585);
spellput("xi", -12556);
spellput("xia", -12359);
spellput("xian", -12346);
spellput("xiang", -12320);
spellput("xiao", -12300);
spellput("xie", -12120);
spellput("xin", -12099);
spellput("xing", -12089);
spellput("xiong", -12074);
spellput("xiu", -12067);
spellput("xu", -12058);
spellput("xuan", -12039);
spellput("xue", -11867);
spellput("xun", -11861);
spellput("ya", -11847);
spellput("yan", -11831);
spellput("yang", -11798);
spellput("yao", -11781);
spellput("ye", -11604);
spellput("yi", -11589);
spellput("yin", -11536);
spellput("ying", -11358);
spellput("yo", -11340);
spellput("yong", -11339);
spellput("you", -11324);
spellput("yu", -11303);
spellput("yuan", -11097);
spellput("yue", -11077);
spellput("yun", -11067);
spellput("za", -11055);
spellput("zai", -11052);
spellput("zan", -11045);
spellput("zang", -11041);
spellput("zao", -11038);
spellput("ze", -11024);
spellput("zei", -11020);
spellput("zen", -11019);
spellput("zeng", -11018);
spellput("zha", -11014);
spellput("zhai", -10838);
spellput("zhan", -10832);
spellput("zhang", -10815);
spellput("zhao", -10800);
spellput("zhe", -10790);
spellput("zhen", -10780);
spellput("zheng", -10764);
spellput("zhi", -10587);
spellput("zhong", -10544);
spellput("zhou", -10533);
spellput("zhu", -10519);
spellput("zhua", -10331);
spellput("zhuai", -10329);
spellput("zhuan", -10328);
spellput("zhuang", -10322);
spellput("zhui", -10315);
spellput("zhun", -10309);
spellput("zhuo", -10307);
spellput("zi", -10296);
spellput("zong", -10281);
spellput("zou", -10274);
spellput("zu", -10270);
spellput("zuan", -10262);
spellput("zui", -10260);
spellput("zun", -10256);
spellput("zuo", -10254);
}
public static void main(string[] args) ...{
string str = null;
str = "谢海101普降喜雨";
system.out.println("spell=" cntospell.getfullspell(str));
str = "张牙舞爪》。，";
system.out.println("spell=" cntospell.getfullspell(str));
str = "啦啦，可耻下场。";
system.out.println("spell=" cntospell.getfullspell(str));
str = "猪油，猪八戒。";
system.out.println("spell=" cntospell.getfullspell(str));
}
private static void spellput(string spell, int ascii) ...{
spellmap.put(spell, new integer(ascii));
}
}
|