怎样实现java系统的可配置性

一个小型的网站，比如个人网站，可以使用最简单的html静态页面就实现了，配合一些图片达到美化效果，所有的页面均存放在一个目录下，这样的网站对系统架构、性能的要求都很简单，随着互联网业务的不断丰富，网站相关的技术经过这些年的发展，已经细分到很细的方方面面，尤其对于大型网站来说，所采用的技术更是涉及面非常广，从硬件到软件、编程语言、数据库、WebServer、防火墙等各个领域都有了很高的要求，已经不是原来简单的html静态网站所能比拟的。

创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都做网站、成都网站制作、成都外贸网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的临洮网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

大型网站，比如门户网站。在面对大量用户访问、高并发请求方面，基本的解决方案集中在这样几个环节：使用高性能的服务器、高性能的数据库、高效率的编程语言、还有高性能的Web容器。但是除了这几个方面，还没法根本解决大型网站面临的高负载和高并发问题。

上面提供的几个解决思路在一定程度上也意味着更大的投入，并且这样的解决思路具备瓶颈，没有很好的扩展性，下面我从低成本、高性能和高扩张性的角度来说说我的一些经验。

1、HTML静态化

其实大家都知道，效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点的新闻频道，甚至他们的其他频道，都是通过信息发布系统来管理和实现的，信息发布系统可以实现最简单的信息录入自动生成静态页面，还能具备频道管理、权限管理、自动抓取等功能，对于一个大型网站来说，拥有一套高效、可管理的CMS是必不可少的。

除了门户和信息发布类型的网站，对于交互性要求很高的社区类型网站来说，尽可能的静态化也是提高性能的必要手段，将社区内的帖子、文章进行实时的静态化，有更新的时候再重新静态化也是大量使用的策略，像Mop的大杂烩就是使用了这样的策略，网易社区等也是如此。

同时，html静态化也是某些缓存策略使用的手段，对于系统中频繁使用数据库查询但是内容更新很小的应用，可以考虑使用html静态化来实现，比如论坛中论坛的公用设置信息，这些信息目前的主流论坛都可以进行后台管理并且存储再数据库中，这些信息其实大量被前台程序调用，但是更新频率很小，可以考虑将这部分内容进行后台更新的时候进行静态化，这样避免了大量的数据库访问请求。

2、图片服务器分离

大家知道，对于Web服务器来说，不管是Apache、IIS还是其他容器，图片是最消耗资源的，于是我们有必要将图片与页面进行分离，这是基本上大型网站都会采用的策略，他们都有独立的图片服务器，甚至很多台图片服务器。这样的架构可以降低提供页面访问请求的服务器系统压力，并且可以保证系统不会因为图片问题而崩溃，在应用服务器和图片服务器上，可以进行不同的配置优化，比如apache在配置ContentType的时候可以尽量少支持，尽可能少的LoadModule，保证更高的系统消耗和执行效率。

3、数据库集群和库表散列

大型网站都有复杂的应用，这些应用必须使用数据库，那么在面对大量访问的时候，数据库的瓶颈很快就能显现出来，这时一台数据库将很快无法满足应用，于是我们需要使用数据库集群或者库表散列。

在数据库集群方面，很多数据库都有自己的解决方案，Oracle、Sybase等都有很好的方案，常用的MySQL提供的Master/Slave也是类似的方案，您使用了什么样的DB，就参考相应的解决方案来实施即可。

上面提到的数据库集群由于在架构、成本、扩张性方面都会受到所采用DB类型的限制，于是我们需要从应用程序的角度来考虑改善系统架构，库表散列是常用并且最有效的解决方案。我们在应用程序中安装业务和应用或者功能模块将数据库进行分离，不同的模块对应不同的数据库或者表，再按照一定的策略对某个页面或者功能进行更小的数据库散列，比如用户表，按照用户ID进行表散列，这样就能够低成本的提升系统的性能并且有很好的扩展性。sohu的论坛就是采用了这样的架构，将论坛的用户、设置、帖子等信息进行数据库分离，然后对帖子、用户按照板块和ID进行散列数据库和表，最终可以在配置文件中进行简单的配置便能让系统随时增加一台低成本的数据库进来补充系统性能。

4、缓存

缓存一词搞技术的都接触过，很多地方用到缓存。网站架构和网站开发中的缓存也是非常重要。这里先讲述最基本的两种缓存。高级和分布式的缓存在后面讲述。

架构方面的缓存，对Apache比较熟悉的人都能知道Apache提供了自己的缓存模块，也可以使用外加的Squid模块进行缓存，这两种方式均可以有效的提高Apache的访问响应能力。

网站程序开发方面的缓存，Linux上提供的Memory Cache是常用的缓存接口，可以在web开发中使用，比如用Java开发的时候就可以调用MemoryCache对一些数据进行缓存和通讯共享，一些大型社区使用了这样的架构。另外，在使用web语言开发的时候，各种语言基本都有自己的缓存模块和方法，PHP有Pear的Cache模块，Java就更多了，.net不是很熟悉，相信也肯定有。

5、镜像

镜像是大型网站常采用的提高性能和数据安全性的方式，镜像的技术可以解决不同网络接入商和地域带来的用户访问速度差异，比如ChinaNet和EduNet之间的差异就促使了很多网站在教育网内搭建镜像站点，数据进行定时更新或者实时更新。在镜像的细节技术方面，这里不阐述太深，有很多专业的现成的解决架构和产品可选。也有廉价的通过软件实现的思路，比如Linux上的rsync等工具。

6、负载均衡

负载均衡将是大型网站解决高负荷访问和大量并发请求采用的终极解决办法。

负载均衡技术发展了多年，有很多专业的服务提供商和产品可以选择，我个人接触过一些解决方法，其中有两个架构可以给大家做参考。

1）硬件四层交换

第四层交换使用第三层和第四层信息包的报头信息，根据应用区间识别业务流，将整个区间段的业务流分配到合适的应用服务器进行处理。 第四层交换功能就象是虚IP，指向物理服务器。它传输的业务服从的协议多种多样，有HTTP、FTP、NFS、Telnet或其他协议。这些业务在物理服务器基础上，需要复杂的载量平衡算法。在IP世界，业务类型由终端TCP或UDP端口地址来决定，在第四层交换中的应用区间则由源端和终端IP地址、TCP和UDP端口共同决定。

在硬件四层交换产品领域，有一些知名的产品可以选择，比如Alteon、F5等，这些产品很昂贵，但是物有所值，能够提供非常优秀的性能和很灵活的管理能力。Yahoo中国当初接近2000台服务器使用了三四台Alteon就搞定了。

2）软件四层交换

大家知道了硬件四层交换机的原理后，基于OSI模型来实现的软件四层交换也就应运而生，这样的解决方案实现的原理一致，不过性能稍差。但是满足一定量的压力还是游刃有余的，有人说软件实现方式其实更灵活，处理能力完全看你配置的熟悉能力。

软件四层交换我们可以使用Linux上常用的LVS来解决，LVS就是Linux Virtual Server，他提供了基于心跳线heartbeat的实时灾难应对解决方案，提高系统的鲁棒性，同时可供了灵活的虚拟VIP配置和管理功能，可以同时满足多种应用需求，这对于分布式的系统来说必不可少。

一个典型的使用负载均衡的策略就是，在软件或者硬件四层交换的基础上搭建squid集群，这种思路在很多大型网站包括搜索引擎上被采用，这样的架构低成本、高性能还有很强的扩张性，随时往架构里面增减节点都非常容易。这样的架构我准备空了专门详细整理一下和大家探讨。

一：高并发高负载类网站关注点之数据库

没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。

一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（主-从）方式进行同步复制，将查询和操作和分别在不同的服务器上进行操作。我推荐的是M-M-Slaves方式，2个主Mysql，多个Slaves，需要注意的是，虽然有2个Master，但是同时只有1个是Active，我们可以在一定时候切换。之所以用2个M，是保证M不会又成为系统的SPOF。

Slaves可以进一步负载均衡，可以结合LVS,从而将select操作适当的平衡到不同的slaves上。

以上架构可以抗衡到一定量的负载，但是随着用户进一步增加，你的用户表数据超过1千万，这时那个M变成了SPOF。你不能任意扩充Slaves，否则复制同步的开销将直线上升，怎么办？我的方法是表分区，从业务层面上进行分区。最简单的，以用户数据为例。根据一定的切分方式，比如id，切分到不同的数据库集群去。

全局数据库用于meta数据的查询。缺点是每次查询，会增加一次，比如你要查一个用户nightsailer,你首先要到全局数据库群找到nightsailer对应的cluster id，然后再到指定的cluster找到nightsailer的实际数据。

每个cluster可以用m-m方式，或者m-m-slaves方式。这是一个可以扩展的结构，随着负载的增加，你可以简单的增加新的mysql cluster进去。

需要注意的是：

1、禁用全部auto_increment的字段

2、id需要采用通用的算法集中分配

3、要具有比较好的方法来监控mysql主机的负载和服务的运行状态。如果你有30台以上的mysql数据库在跑就明白我的意思了。

4、不要使用持久性链接（不要用pconnect）,相反，使用sqlrelay这种第三方的数据库链接池，或者干脆自己做，因为php4中mysql的链接池经常出问题。

二：高并发高负载网站的系统架构之HTML静态化

其实大家都知道，效率最高、消耗最小的就是纯静态化 的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是 最有效的方法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点 的新闻频道，甚至他们的其他频道，都是通过信息发布系统来管理和实现的，信息发布系统可以实现最简单的信息录入自动生成静态页面，还能具备频道管理、权限 管理、自动抓取等功能，对于一个大型网站来说，拥有一套高效、可管理的CMS是必不可少的。

除了门户和信息发布类型的网站，对于交互性要求很高的社区类型网站来说，尽可能的静态化也是提高性能的必要手段，将社区内的帖子、文章进行实时的静态化，有更新的时候再重新静态化也是大量使用的策略，像Mop的大杂烩就是使用了这样的策略，网易社区等也是如此。

　 　同时，html静态化也是某些缓存策略使用的手段，对于系统中频繁使用数据库查询但是内容更新很小的应用，可以考虑使用html静态化来实现，比如论坛 中论坛的公用设置信息，这些信息目前的主流论坛都可以进行后台管理并且存储再数据库中，这些信息其实大量被前台程序调用，但是更新频率很小，可以考虑将这 部分内容进行后台更新的时候进行静态化，这样避免了大量的数据库访问请求高并发。

网站HTML静态化解决方案

当一个Servlet资源请求到达WEB服务器之后我们会填充指定的JSP页面来响应请求:

HTTP请求---Web服务器---Servlet--业务逻辑处理--访问数据--填充JSP--响应请求

HTML静态化之后:

HTTP请求---Web服务器---Servlet--HTML--响应请求

静态访求如下

Servlet:

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

if(request.getParameter("chapterId") != null){

String chapterFileName = "bookChapterRead_"+request.getParameter("chapterId")+".html";

String chapterFilePath = getServletContext().getRealPath("/") + chapterFileName;

File chapterFile = new File(chapterFilePath);

if(chapterFile.exists()){response.sendRedirect(chapterFileName);return;}//如果有这个文件就告诉浏览器转向

INovelChapterBiz novelChapterBiz = new NovelChapterBizImpl();

NovelChapter novelChapter = novelChapterBiz.searchNovelChapterById(Integer.parseInt(request.getParameter("chapterId")));//章节信息

int lastPageId = novelChapterBiz.searchLastCHapterId(novelChapter.getNovelId().getId(), novelChapter.getId());

int nextPageId = novelChapterBiz.searchNextChapterId(novelChapter.getNovelId().getId(), novelChapter.getId());

request.setAttribute("novelChapter", novelChapter);

request.setAttribute("lastPageId", lastPageId);

request.setAttribute("nextPageId", nextPageId);

new CreateStaticHTMLPage().createStaticHTMLPage(request, response, getServletContext(),

chapterFileName, chapterFilePath, "/bookRead.jsp");

}

}

生成HTML静态页面的类:

package com.jb.y2t034.thefifth.web.servlet;

import java.io.ByteArrayOutputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import javax.servlet.RequestDispatcher;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpServletResponseWrapper;

/**

* 创建HTML静态页面

* 功能：创建HTML静态页面

* 时间：2009年1011日

* 地点：home

* @author mavk

*

*/

public class CreateStaticHTMLPage {

/**

* 生成静态HTML页面的方法

* @param request 请求对象

* @param response 响应对象

* @param servletContext Servlet上下文

* @param fileName 文件名称

* @param fileFullPath 文件完整路径

* @param jspPath 需要生成静态文件的JSP路径(相对即可)

* @throws IOException

* @throws ServletException

*/

public void createStaticHTMLPage(HttpServletRequest request, HttpServletResponse response,ServletContext servletContext,String fileName,String fileFullPath,String jspPath) throws ServletException, IOException{

response.setContentType("text/html;charset=gb2312");//设置HTML结果流编码(即HTML文件编码)

RequestDispatcher rd = servletContext.getRequestDispatcher(jspPath);//得到JSP资源

final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();//用于从ServletOutputStream中接收资源

final ServletOutputStream servletOuputStream = new ServletOutputStream(){//用于从HttpServletResponse中接收资源

public void write(byte[] b, int off,int len){

byteArrayOutputStream.write(b, off, len);

}

public void write(int b){

byteArrayOutputStream.write(b);

}

};

final PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(byteArrayOutputStream));//把转换字节流转换成字符流

HttpServletResponse httpServletResponse = new HttpServletResponseWrapper(response){//用于从response获取结果流资源(重写了两个方法)

public ServletOutputStream getOutputStream(){

return servletOuputStream;

}

public PrintWriter getWriter(){

return printWriter;

}

};

rd.include(request, httpServletResponse);//发送结果流

printWriter.flush();//刷新缓冲区，把缓冲区的数据输出

FileOutputStream fileOutputStream = new FileOutputStream(fileFullPath);

byteArrayOutputStream.writeTo(fileOutputStream);//把byteArrayOuputStream中的资源全部写入到fileOuputStream中

fileOutputStream.close();//关闭输出流，并释放相关资源

response.sendRedirect(fileName);//发送指定文件流到客户端

}

}

JAVA如何实现代码提示？

实现方法请具体参照《Eclipse swt/Jface核心编程》

第21章 文本处理.

21.1 文本处理概述... 409

21.2 项目实战：JavaScript编辑器... 409

21.2.1 主窗口预览... 409

21.2.2 项目文件结构... 410

21.3 主窗口模块... 411

21.3.1 代码实现... 411

21.3.2 主窗口程序代码分析... 414

21.3.3 启动主窗口程序... 416

21.4 代码着色... 417

21.4.1 源代码配置类（SourceViewerConfiguration）... 417

21.4.2 基于规则的代码扫描器类（RuleBasedScanner）... 419

21.4.3 设置代码扫描规则... 420

21.4.4 提取类（Token）和文本属性类（TextAttribute）... 423

21.5 内容辅助... 423

21.5.1 配置编辑器的内容助手... 424

21.5.2 内容辅助类... 424

21.5.3 辅助建议类（CompletionProposal）... 426

21.6 文档的撤销与重复... 427

21.6.1 文档管理器对象（DefaultUndoManager）... 427

21.6.2 撤销操作的实现... 427

21.6.3 恢复操作的实现... 428

21.7 查找与替换窗口... 429

21.7.1 窗口的界面设计... 429

21.7.2 查找功能的实现... 433

21.7.3 替换功能的实现... 434

21.8 首选项的对话框... 434

21.8.1 首选项页面的代码实现... 435

21.8.2 打开首选项页面的代码... 436

21.9 文件的打开、保存与打印... 437

21.9.1 打开文件... 437

21.9.2 保存文件... 437

21.9.3 打印文件... 438

21.10 帮助对话框... 439

21.11 其他的一些工具类... 440

21.11.1 事件管理类... 440

21.11.2 资源管理类... 441

21.11.3 程序中使用的常量... 443

21.12 本章小结... 444

如何实现JAVA程序根据用户的配置开机启动

看了楼上的发言，你有资格说别人傻吗？看清楚楼主的问题好不好！楼主的意思是直接在java程序中配置实现，而不是像你那么傻的手动去实现！

转载两篇文章，结合起来可以实现java应用程序开机自动启动

可能也有别的好方法，这只是其中的一种

思路就是将java应用程序打包成.jar文件，然后转成.exe，通过修改注册表来增加删除启动项，即将安装后的.exe执行文件添加到注册表中；

首先将java应用程序打包成.jar文件，可以利用如下代码找到.jar文件的绝对路径，即也可以找到安装后的.exe执行文件

转载：

对于Java程序，无论是未打包的还是打包的JAR或WAR文件，有时候都需要获取它运行所在目录信息，如何做到这一点呢？

在Java处理的文件系统中，目录的表示方式有两种：

（1）绝对目录，它以"/"为起始字符，代表从根目录下开始寻找给出的目录，如/c:/java

（2）相对路径，它以不带“/”的目录名表示，表示以当前Java程序正在运行的目录作为起始目录来寻找给出的目录。如java/classes。在相对路径中，有一些特定的字符，可以代表特的的目录，比如，“.”代表当前目录，“..”代表当前目录的上一级目录。在网上很多给出的例子中，就是利用"."作为目录名，构造File对象的实例，然后通过File对象的方法来获取当前程序运行的目录。

这种方法虽然简单，但有时不能正确的得出当前程序的运行目录。原因在于，运行Java程序不一定要进入到该程序的类文件或JAR文件所在的目录，只要在运行时指定了正确的类路径信息，就可以在任何目录中运行Java程序，此时利用这种方法只能得到发出运行命令时所在的目录信息。

从上面的分析可以看出，对于很多Java程序，尤其是WEB程序，利用当前路径的“.”表示法，都不能满足要求。那么怎样才能正确的得到运行目录信息呢？

在Web程序中，利用Servlet API可以获得一些路径信息，比如HttpServletRequest接口中定义的getRealPath方法，但类似这些方法都依赖于Servlet环境，不便于程序的单元测试。

本文提供了一种只使用Java标准API的路径探测方法，就是利用ClassLoader抽象类。

利用java.lang.Class的getClassLoader方法，可以获得给定类的ClassLoader实例，它的getResource方法可以获得当前类装载器中的资源的位置，我们可以利用类文件的名称作为要查找的资源，经过处理后就可获得当前Java程序的运行位置信息，其伪代码如下：

获得Class参数的所在的类名

取得该类所在的包名

将包名转换为路径

利用getResource得到当前的类文件所在URL

利用URL解析出当前Java程序所在的路径

具体代码如下：

java代码：

Java代码

/**-----------------------------------------------------------------------

*getAppPath需要一个当前程序使用的Java类的class属性参数，它可以返回打包过的

*Java可执行文件（jar，war）所处的系统目录名或非打包Java程序所处的目录

*@param cls为Class类型

*@return 返回值为该类所在的Java程序运行的目录

-------------------------------------------------------------------------*/

public static String getAppPath(Class cls){

//检查用户传入的参数是否为空

if(cls==null)

throw new java.lang.IllegalArgumentException("参数不能为空！");

ClassLoader loader=cls.getClassLoader();

//获得类的全名，包括包名

String clsName=cls.getName()+".class";

//获得传入参数所在的包

Package pack=cls.getPackage();

String path="";

//如果不是匿名包，将包名转化为路径

if(pack!=null){

String packName=pack.getName();

//此处简单判定是否是Java基础类库，防止用户传入JDK内置的类库

if(packName.startsWith("java.")||packName.startsWith("javax."))

throw new java.lang.IllegalArgumentException("不要传送系统类！");

//在类的名称中，去掉包名的部分，获得类的文件名

clsName=clsName.substring(packName.length()+1);

//判定包名是否是简单包名，如果是，则直接将包名转换为路径，

if(packName.indexOf(".")0) path=packName+"/";

else{//否则按照包名的组成部分，将包名转换为路径

int start=0,end=0;

end=packName.indexOf(".");

while(end!=-1){

path=path+packName.substring(start,end)+"/";

start=end+1;

end=packName.indexOf(".",start);

}

path=path+packName.substring(start)+"/";

}

}

//调用ClassLoader的getResource方法，传入包含路径信息的类文件名

java.net.URL url =loader.getResource(path+clsName);

//从URL对象中获取路径信息

String realPath=url.getPath();

//去掉路径信息中的协议名"file:"

int pos=realPath.indexOf("file:");

if(pos-1) realPath=realPath.substring(pos+5);

//去掉路径信息最后包含类文件信息的部分，得到类所在的路径

pos=realPath.indexOf(path+clsName);

realPath=realPath.substring(0,pos-1);

//如果类文件被打包到JAR等文件中时，去掉对应的JAR等打包文件名

if(realPath.endsWith("!"))

realPath=realPath.substring(0,realPath.lastIndexOf("/"));

/*------------------------------------------------------------

ClassLoader的getResource方法使用了utf-8对路径信息进行了编码，当路径

中存在中文和空格时，他会对这些字符进行转换，这样，得到的往往不是我们想要

的真实路径，在此，调用了URLDecoder的decode方法进行解码，以便得到原始的

中文及空格路径

-------------------------------------------------------------*/

try{

realPath=java.net.URLDecoder.decode(realPath,"utf-8");

}catch(Exception e){throw new RuntimeException(e);}

return realPath;

}//getAppPath定义结束

//-----------------------------------------------------------------

该方法既可以用于JAR或WAR文件，也可以用于非JAR文件。但要注意以下2点：

不要传递系统的类，作为getAppPath的参数，如java.lang.String.class，当然，也不要传递那些已经位于JDK中的那些类，比如xml相关的一些类等等。

要传递应该是程序中主要的运行类，不要传递程序中的支持类库中的类文件，也就是那些第三方的类库中的类文件，否则得到的将是那些类库的位置。

然后可以通过修改注册表来增加开机启动项:

转载：

需要修改的注册表项

[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run] 开机自动运行程序

[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce] 开机自动运行程序 且 仅运行一次

[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices] 开机自动运行服务

JDK 从1.4开始提供操作 Windows 的 API 是 Preferences，因为这个 API 也是跨平台的，所功能比较弱，在 Win32 下只能用来操作 HKCU\Software\JavaSoft 和 HKLM\Software\JavaSoft 下及子节点的数据。

自由访问注册表其他键的值光用 Java 是做不到的，必然方案就是 JNI，这里我使用的是Windows Registry API Native Interface 下的 registry-3.1.3.zip(包含源代码)。可以利用它访问、修改、导出注册表项到文件等。解开 registry-3.1.3.zip，在 bin 目录中可以看到两个文件 ICE_JNIRegistry.dll 和 registry.jar，动态库就是本地代码实现。

com.ice.jni.registry.Registry.main() 就是 registry 的示例代码，动态库 ICE_JNIRegistry.dll 也是在这个类的静态块中被加载的，记得要把 ICE_JNIRegistry.dll 放在它能够被加载的位置上，比如你把 registry-3.1.3.zip 解压到 c:\registry-3.1.3，在命令行下你可以进入到这个目录中，并执行。

代码：

Java代码

package org.zh.ss.util;

import com.ice.jni.registry.*;

import java.text.SimpleDateFormat;

/** *//**

* java 操作注册表

* @author 李志远

*/

public class RegeditTool {

static SimpleDateFormat shortDateFormat = new SimpleDateFormat("yyyy-MM-dd");

/** *//** */

/** *//** Creates a new instance of test */

// 把信息存储到注册表HKEY_LOCAL_MACHINE下的某个节点的某一变量中，有则修改，无则创建

public static boolean setValue(String folder, String subKeyNode,

String subKeyName, String subKeyValue) {

try {

RegistryKey software = Registry.HKEY_LOCAL_MACHINE

.openSubKey(folder);

RegistryKey subKey = software.createSubKey(subKeyNode, "");

subKey

.setValue(new RegStringValue(subKey, subKeyName,

subKeyValue));

subKey.closeKey();

return true;

} catch (NoSuchKeyException e) {

e.printStackTrace();

} catch (NoSuchValueException e) {

e.printStackTrace();

} catch (RegistryException e) {

e.printStackTrace();

}

return false;

}

// 删除注册表中某节点下的某个变量

public static boolean deleteValue(String folder, String subKeyNode,

String subKeyName) {

try {

RegistryKey software = Registry.HKEY_LOCAL_MACHINE

.openSubKey(folder);

RegistryKey subKey = software.createSubKey(subKeyNode, "");

subKey.deleteValue(subKeyName);

subKey.closeKey();

return true;

} catch (NoSuchKeyException e) {

System.out.println("NOsuchKey_delete");

} catch (NoSuchValueException e) {

System.out.println("NOsuchValue_delete");

} catch (RegistryException e) {

e.printStackTrace();

}

return false;

}

// 删除注册表中某节点下的某节点

public static boolean deleteSubKey(String folder, String subKeyNode) {

try {

RegistryKey software = Registry.HKEY_LOCAL_MACHINE

.openSubKey(folder);

software.deleteSubKey(subKeyNode);

software.closeKey();

return true;

} catch (NoSuchKeyException e) {

e.printStackTrace();

} catch (RegistryException e) {

e.printStackTrace();

}

return false;

}

// 打开注册表项并读出相应的变量名的值

public static String getValue(String folder, String subKeyNode,

String subKeyName) {

String value = "";

try {

RegistryKey software = Registry.HKEY_LOCAL_MACHINE

.openSubKey(folder);

RegistryKey subKey = software.openSubKey(subKeyNode);

value = subKey.getStringValue(subKeyName);

subKey.closeKey();

} catch (NoSuchKeyException e) {

value = "NoSuchKey";

// e.printStackTrace();

} catch (NoSuchValueException e) {

value = "NoSuchValue";

// e.printStackTrace();

} catch (RegistryException e) {

e.printStackTrace();

}

return value;

}

// 测试

public static void main(String[] args) {

setValue("SOFTWARE", "Microsoft\\Windows\\CurrentVersion\\Run", "test",

"C:\\1.exe");

}

}

这样，就可以在软件中添加，删除，修改开机启动项了

求JAVA struts拦截器配置代码

第一种实现:继承MethodFilterInterceptor

import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;public class UserCheck2Interceptor extends MethodFilterInterceptor { public UserCheck2Interceptor()

{ //过滤不拦截的方法

this.setExcludeMethods("check");//如果是多个的方法可以用逗号隔开

}

@Override

protected String doIntercept(ActionInvocation arg0) throws Exception

{ //防止不登陆地址访问

Userinfo user=(Userinfo)arg0.getInvocationContext().getSession().get("user");

String result="login";

if(user!=null)

{

//action的方法的结果

result=arg0.invoke();//调用action的具体方法

}

System.out.println("用户校验！");

return result;

}}第二种实现:实现接口Interceptor MethodFilterInterceptor 也实现了Interceptor 接口import com.opensymphony.xwork2.ActionInvocation;

import com.opensymphony.xwork2.interceptor.Interceptor;public class UserCheckInterceptor implements Interceptor { public UserCheckInterceptor()

{

}

public void destroy()

{

}

public void init()

{

}

/*

* 实现拦截的功能(在调用action之前执行该拦截器,对用户的合法性进行校验,如果不合法直接转到login.jsp，如果合法登入则继续运行)

*/

public String intercept(ActionInvocation arg0) throws Exception

{

Userinfo user=(Userinfo)arg0.getInvocationContext().getSession().get("user");

String result="login";

if(user!=null)

{

//action的方法的结果

result=arg0.invoke();//调用action的具体方法

}

System.out.println("用户校验！");

return result;

}}

最后配置struts.xml?xml version="1.0" encoding="UTF-8"?

!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

" "

struts!--修改struts.xml 文件 是否会重新加载--

constant name="struts.configuration.xml.reload" value="true"/constant

constant name="struts.i18n.encoding" value="GBK"/constant

constant name="struts.custom.i18n.resources" value="globalMsg"/constant

!--自定义包作为默认的--

package name="test" extends="struts-default"

interceptors !-- 自定义拦截器 -- !-- 实现Interceptor 接口的拦截器 --

interceptor name="usercheckInterceptor" class="test.interceptors.UserCheckInterceptor"/interceptor !-- 继承MethodFilterInterceptor 的拦截器 --

interceptor name="usercheck2Interceptor" class="test.interceptors.UserCheck2Interceptor"/interceptor

interceptor-stack name="itfutureStack" !-- 使用usercheck2Interceptor拦截器 --

interceptor-ref name="usercheck2Interceptor"/interceptor-ref !-- 注意要引用原先struts2默认的17个拦截器 --

interceptor-ref name="defaultStack"/interceptor-ref

/interceptor-stack

/interceptors !-- 设置此命名空间的默认拦截器为用户自定义的test拦截器 --

default-interceptor-ref name="test"/default-interceptor-ref

/package

/struts

使用的时候就直接继承test命名空间就好了,建议使用继承MethodFilterInterceptor 的拦截器,它实现了对不必要进行拦截的方法的过滤.如登陆的方法

网页标题：java可配置代码实现 java可配置代码实现什么功能
URL链接：http://hbruida.cn/article/dosdscj.html