iLeichun

当前位置:首页

微软高管建议禁止被感染计算机接入互联网

分类:网络安全  来源:网络  时间:2010-10-23 13:16:55

据国外媒体报道,微软高级执行副总裁斯科特·查尼(Scott Charney)周四表示,为了确保互联网安全,被病毒感染的计算机应该被禁止接入互联网。

  查尼在国际安全解决方案欧洲大会(ISSE)上称,为了避免僵尸网络和其他恶意软件感染用户PC,应该禁止被感染的计算机访问互联网,正如现实生活中的传染病人应该被隔离一样。

  查尼表示,这需要政府、IT业界、互联网服务供应商和用户的配合,对消费电子设备的“健康状况”进行评估。如果存在不安全因素,则不允许接入互联网或其他重要资源。

  查尼称,当前的防火墙、杀毒软件和补丁自动更新还不足以确保计算机安全,尽管付出了不少努力,但还是被恶意软件感染,或成为僵尸网络的一部分。

  查尼的建议遭到不少网民的反对。有网民称,把不安全的计算机排除在互联网之外,按照该逻辑,还应该把运行Windows的计算机与互联网隔离。

Java无法编写?通过JNI本地编写来解决

分类:Java  来源:网络  时间:2010-10-21 23:47:31

  在您的程序中使用JNI并不是一件容易的事情,然而,JNI的性能和使用原有代码的能力将会为您的Java程序添加更多的功能并且能胜任更多的挑战。

  Java本地接口(JNI——Java Native Interface)允许运行在Java虚拟机(JVM——Java Virtual Machine)上的代码调用本地程序和类库,或者被它们调用,这些程序和类库可以是其它语言编写的,比如C、C++或者汇编语言。当一个程序无法完全使用Java编写时,开发者可以通过JNI来编写本地方法,比如标准Java类库并不支持的依赖于平台的特色或者程序库。JNI还可以用于修改现有的使用其它语言编写的程序,使它们可以通过Java编写的程序来访问。很多基本类库都依赖JNI来为开发者和用户提供服务,比如文件的输入/输出和音频功能。在基本类库中包含的对于性能和平台敏感的API可以允许所有的Java程序以安全和平台无关的方式来使用这些功能,在采用JNI之前,开发者需要明确这些功能并不是已经包含在Java标准类库中的,在这篇文章中,我将会讲解JNI是如何工作的以及本地类型是如何映射到Java的类型和类库的。

  JNI工作原理

  在JNI中,本地函数是通过一个独立的.c或.cpp文件来实现的(C++为JNI提供的界面会更简洁一些)。当JVM调用该函数时,它传递了一个JNIEnv指针、一个jobject指针和通过Java方法定义的Java参数,JNI函数的形式如下:


 JNIEXPORT void JNICALL    
Java_ClassName_MethodName  (JNIEnv *env, jobjectobj)    
{    
//Method native implemenation   

  env指针是一个包含了JVM接口的结构,它包含了与JVM进行交互以及与Java对象协同工作所必需的函数,示例中的JNI函数可以在本地数组和Java数组类型之间、本地字符串和Java字符串类型之间进行转换,其功能还包括对象的实例化、抛出异常等。基本上您可以使用JNIEnv来实现所有Java能做到的事情,虽然要简单很多。更加正式的解释是这样的,本地代码通过调用JNI的函数来访问JVM,这是通过一个界面指针实现的(界面指针实际上是指向指针的指针),该指针指向一个指针数组,数组中的每个指针都指向了一个界面函数,而每个界面函数都是在数组中预先定义过的。本地方法将JNI界面指针当作一个参数,如果在同一个Java线程中,出现对该本地方法的多重调用,JVM则保证传递相同的界面指针到本地方法。不过,一个本地方法可以被不同的Java线程调用,因而也可能会收到不同的JNI界面指针。

  本地方法是通过System.loadLibrary方法加载的,在以下的例子中,类的初始化方法加载了一个指定平台的本地类库,该类库定义了本地方法:


 packagepkg;     
class Cls    
{    
native double f(inti, String s);    
static    
{     
System.loadLibrary(pkg_Cls");    
}    

  System.loadLibrary方法的参数是一个类库的名称,它可以由程序员任意选取,系统则遵循一个标准的本地化平台的方式来转换类库的名称到一个本地类库的名称。例如,在Solaris操作系统中会将pkg_Cls转换为libpkg_Cls.so,而Win32系统则会将同样的pkg_Cls转换为pkg_Cls.dll。

  动态指针会根据它们的名字来进行解析,一个本地方法的名称是按照组件进行连接的,它包含了:前缀“Java_”、一个分离的合法的类名称和一个分离的方法名称。注意:微软的JVM有相同的机制从Java调用本地Windows代码,该机制被称为原始本地接口(Raw Native Interface (RNI))。基本类型,比如整型、字符等等,是在Java和本地代码间进行拷贝的,而其他的自定义Java对象则是通过引用来传递的。这个表格展示了Java和本地代码之间的类型映射,这些类型是可以互换的,您可以在您使用int类型的位置使用jint类型,当然反过来也一样,而且不需要任何类型转化。但是,Java的字符串和数组类型和本地的字符串与数组类型之间的转换就比较困难了,如果您使用的jstring类型中出现了字符“*”,您的代码会造成JVM的崩溃,以下的例子说明了您应当如何正确使用字符串:


 JNIEXPORT void JNICALL    
Java_ClassName_MethodName    
(JNIEnv *env, jobjectobj, jstringjavaString)    
{     
//Get the native string from    
Java string  const char    
*nativeString =    
env->GetStringUTFChars(env,javaString, 0);    
printf("%s", nativeString);     
env->ReleaseStringUTFChars(env,javaString, nativeString);    

  您需要使用界面指针env来操作Java对象。

Eclipse 3.5提前发布 新增两千四百万行代码

分类:Java  来源:网络  时间:2010-10-21 23:45:59

Eclipse 3.5已经于6月24日发布,比Eclipse官网公布的预计发布日期提前了整整两天。

  本次Eclipse伽利略是有史以来Eclipse最大的更新,包括33个项目和2千4百多万行代码。来自44个不同组织的超过380个贡献者都参与了这次发布。

  Eclipse的本身只是一个框架平台,但是众多插件的支持使得Eclipse拥有其他功能相对固定的IDE软件很难具有的灵活性。许多软件开发商以Eclipse为框架开发自己的IDE。

  Eclipse 3.5新特性概述

  ◆Solaris x86已经加入支持行列

  ◆Eclipse富客户端平台现在包含了一个OSGi声明式服务(Declarative Services——DS)的实现

  ◆增强目标编辑器,以支持目标定义中的新特性

  ◆有一个新的目标平台偏好页面

  本次更新包括了很多企业方面的升级。更新主要有三个主要趋势:

  1. 企业使用方面的扩展

  2. Eclipse模型技术的创新

  3. Eclipse runtime技术的增强

  同时官方网站的Blog区,在6月24日也同时发布多个关于Eclipse 3.5的文章。

Java的文件名必须和公共类名相同的原因

分类:Java  来源:网络  时间:2010-10-21 23:45:03

 首先Java是被解释执行的。它在运行时并不是将所有的class文件全都放到内存中。而是在遇到import的时候才去相应的文件目录找相应的class文件。

  对于一个public类,它是可以被项目中任何一个类所引用的,只需在使用它前import一下它所对应的class文件即可。将类名与文件名一一对应就可以方便虚拟机

  在相应的路径(包名)中找到相应的类的信息。如果不这么做的话,就很难去找,而且开销也会很大。

  一下是我写的一个比较“恶心”的程序来说明这个问题,大家在使用前先要将自己JDK的bin目录设置到环境变量path中去:

 


 import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.FileNotFoundException;
  public class Test
  {
  public static void main(String[] args) {
  Object b = null;
  try {
  b = Class.forName("Hello").newInstance();
  }
  catch(InstantiationException e) {
  }
  catch(IllegalAccessException e) {
  }
  catch(ClassNotFoundException e) {
  try {
  FileOutputStream file = new FileOutputStream("Hello.java");
  String s = "public class Hello { public Hello() { Syst"
  + "em.out.println("Hello, world!"); } } ";
  file.write(s.getBytes());
  Process p = Runtime.getRuntime().exec("javac Hello.java");
  System.out.println("The return value is: " + p.waitFor());
  b = Class.forName("Hello").newInstance();
  }
  catch(FileNotFoundException ee) {
  }
  catch(IOException ee) {
  }
  catch(InterruptedException ee) {
  }
  catch(InstantiationException ee) {
  }
  catch(IllegalAccessException ee) {
  }
  catch(ClassNotFoundException ee) {
  }
  }
  }
  }

 

Java线程:并发协作-死锁

分类:Java  来源:网络  时间:2010-10-21 23:44:13

  线程发生死锁可能性很小,即使看似可能发生死锁的代码,在运行时发生死锁的可能性也是小之又小。

  发生死锁的原因一般是两个对象的锁相互等待造成的。

  在《Java线程:线程的同步与锁》一文中,简述死锁的概念与简单例子,但是所给的例子是不完整的,这里给出一个完整的例子。


  /**
  * Java线程:并发协作-死锁
  *
  * @author Administrator 2009-11-4 22:06:13
  */
  public class Test {
  public static void main(String[] args) {
  DeadlockRisk dead = new DeadlockRisk();
  MyThread t1 = new MyThread(dead, 1, 2);
  MyThread t2 = new MyThread(dead, 3, 4);
  MyThread t3 = new MyThread(dead, 5, 6);
  MyThread t4 = new MyThread(dead, 7, 8);
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  }
  }
  class MyThread extends Thread {
  private DeadlockRisk dead;
  private int a, b;
  MyThread(DeadlockRisk dead, int a, int b) {
  this.dead = dead;
  this.a = a;
  this.b = b;
  }
  @Override
  public void run() {
  dead.read();
  dead.write(a, b);
  }
  }
  class DeadlockRisk {
  private static class Resource {
  public int value;
  }
  private Resource resourceA = new Resource();
  private Resource resourceB = new Resource();
  public int read() {
  synchronized (resourceA) {
  System.out.println("read():" + Thread.currentThread().getName() + "获取了resourceA的锁!");
  synchronized (resourceB) {
  System.out.println("read():" + Thread.currentThread().getName() + "获取了resourceB的锁!");
  return resourceB.value + resourceA.value;
  }
  }
  }
  public void write(int a, int b) {
  synchronized (resourceB) {
  System.out.println("write():" + Thread.currentThread().getName() + "获取了resourceA的锁!");
  synchronized (resourceA) {
  System.out.println("write():" + Thread.currentThread().getName() + "获取了resourceB的锁!");
  resourceA.value = a;
  resourceB.value = b;
  }
  }
  }
  }

  下面死锁的情况发生了,真是难得一见啊:

Java对MY SQL的连接仿方法介绍

分类:Java  来源:网络  时间:2010-10-21 23:42:44

对于数据库的访问,现在对数据库进行设置。

  ف.首先打开TCP服务,在打开一个端口。

  2.新建一个用户,对用户进行映射。(有时候会碰到一个错误,可能是服务器身份验证为windows身份验证模式,将其改为SQL验证模式)

  ك.下载JDBC数据库驱动程序。解压将jdbc.jar放到根目录下。

  ل.在Eclipse中导入JDBC驱动。

  م.在Eclpse中建立一个JAVA Project。


   import java.sql.*;
  public class Test {
  public static void main(String[] srg) {
  String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; //加载JDBC驱动
  String dbURL = "jdbc:sqlserver://localhost:1433; DatabaseName=sample"; //连接服务器和数据库sample
  String userName = "sa"; //默认用户名
  String userPwd = "123456"; //密码
  Connection dbConn;
  try {
  Class.forName(driverName);
  dbConn = DriverManager.getConnection(dbURL, userName, userPwd);
  System.out.println("Connection Successful!"); //如果连接成功 控制台输出Connection Successful!
  } catch (Exception e) {
  e.printStackTrace();
  }
  }
  }

Java入门:面向对象的思维方法

分类:Java  来源:网络  时间:2010-10-21 23:39:55

 我是从学习Java编程开始接触OOP(面向对象编程),刚开始使用Java编写程序的时候感觉很别扭,因为我早以习惯用C来编写程序,很欣赏C的简洁性和高效性,喜欢C简练而表达能力丰富的风格,特别忍受不了Java运行起来慢吞吞的速度,相对冗长的代码,而且一个很简单的事情,要写好多类,一个类调用一个类,心里的抵触情绪很强。

  我对Java的面向对象的特性琢磨良久,自认为有所领悟,也开始有意识的运用OOP风格来写程序,然而还是经常会觉得不知道应该怎样提炼类,面对一个具体的问题的时候,会觉得脑子里千头万绪的,不知道怎么下手,一不小心,又会回到原来的思路上去。

  举个例子,要发广告邮件,广告邮件列表存在数据库里面。倘若用C来写的话,一般会这样思考,先把邮件内容读入,然后连接数据库,循环取邮件地址,调用本机的qmail的sendmail命令发送。

  然后考虑用Java来实现,既然是OOP,就不能什么代码都塞到main过程里面,于是就设计了三个类:

  一个类是负责读取数据库,取邮件地址,调用qmail的sendmail命令发送;

  一个类是读邮件内容,MIME编码成HTML格式的,再加上邮件头;

  一个主类负责从命令读参数,处理命令行参数,调用发email的类。

  把一件工作按照功能划分为3个模块分别处理,每个类完成一件模块任务。

  仔细的分析一下,就会发现这样的设计完全是从程序员实现程序功能的角度来设计的,或者说,设计类的时候,是自低向上的,从机器的角度到现实世界的角度来分析问题的。因此在设计的时候,就已经把程序编程实现的细节都考虑进去了,企图从底层实现程序这样的出发点来达到满足现实世界的软件需求的目标。

  这样的分析方法其实是不适用于Java这样面向对象的编程语言,因为,如果改用C语言,封装两个C函数,都会比Java实现起来轻松的多,逻辑上也清楚的多。

  我觉得面向对象的精髓在于考虑问题的思路是从现实世界的人类思维习惯出发的,只要领会了这一点,就领会了面向对象的思维方法。

  举一个非常简单的例子:假使现在需要写一个网页计数器,客户访问一次页面,网页计数器加1,计数器是这样来访问的http://hostname/count.cgi?id=xxx

  后台有一个数据库表,保存每个id(一个id对应一个被统计访问次数的页面)的计数器当前值,请求页面一次,对应id的计数器的字段加1(这里我们忽略并发更新数据库表,出现的表锁定的问题)。

  如果按照一般从程序实现的角度来分析,我们会这样考虑:首先是从HTTP GET请求取到id,然后按照id查数据库表,获得某id对应的访问计数值,然后加1,更新数据库,最后向页面显示访问计数。

  现在假设一个没有程序设计经验的人,他会怎样来思考这个问题的呢?他会提出什么样的需求呢?他很可能会这样想:

  我需要有一个计数器,这个计数器应该有这样的功能,刷新一次页面,访问量就会加1,另外最好还有一个计数器清0的功能,当然计数器如果有一个可以设为任意值的功能的话,我就可以作弊了。

  做为一个没有程序设计经验的人来说,他完全不会想到对数据库应该如何操作,对于HTTP变量该如何传递,他考虑问题的角度就是我有什么需求,我的业务逻辑是什么,软件应该有什么功能。

  按照这样的思路(请注意,他的思路其实就是我们平时在生活中习惯的思维方式),我们知道需要有一个计数器类 Counter,有一个必须的和两个可选的方法:

  


getCount()
  // 取计数器值方法
  resetCounter()
  // 计数器清0方法
  setCount()
  // 设计数器为相应的值方法
  把Counter类完整的定义如下:
  public class Counter
  {
  public int getCount(int id)
  {
  }
  public void resetCounter(int id)
  {
  }
  public void setCount
  (int id, int currentCount)
  {
  }
  }

  解决问题的框架已经有了,来看一下如何使用Counter。在count.cgi里面调用Counter来计数,程序片断如下:

  // 这里从HTTP环境里面取id值

  ...

  Counter myCounter = new Counter();

  // 获得计数器

  int currentCount = myCounter.getCount(id);

  // 从计数器中取计数

  // 这里向客户浏览器输出

  ...

  程序的框架全都写好了,剩下的就是实现Counter类方法里面具体的代码了,此时才去考虑具体的程序语言实现的细节,比如,在getCount()方法里面访问数据库,更新计数值。 从上面的例子中看到,面向对象的思维方法其实就是我们在现实生活中习惯的思维方式,是从人类考虑问题的角度出发,把人类解决问题的思维方式逐步翻译成程序能够理解的思维方式的过程,在这个翻译的过程中,软件也就逐步被设计好了。 在运用面向对象的思维方法进行软件设计的过程中,最容易犯的错误就是开始分析的时候,就想到了程序代码实现的细节,因此封装的类完全是基于程序实现逻辑,而不是基于解决问题的业务逻辑。 学习JDBC编程的经典错误问法是:“我怎样封装对数据库的select操作?” 面向对象的设计是基于解决业务问题的设计,而不是基于具体编程技术的设计。我不会去封装select语句的,我只封装解决问题的业务逻辑,对数据库的读取是在业务逻辑的编码实现阶段才去考虑的问题。 回过头看上面那个发广告邮件的例子,应该如何应用面向对象的思维方法呢? 对于一个邮件来说,有邮件头,邮件体,和邮件地址这三个属性,发送邮件,需要一个发送的方法,另外还需要一个能把所有邮件地址列出来的方法。所以应该如下设计: 类JunkMail 属性:

  •   head
  •   body
  •   address

 方法:


public class JunkMail
  {
  private String head;
  private String body;
  private String address;
  public JunkMain()
  {
  // 默认的类构造器
  // 从外部配置文件读邮件头和邮件体
  this.head=...;
  this.body=...;
  }
  public static boolean
  sendMail(String address)
  {
  // 调用qmail,发送email
  }
  public static Collection listAllMail()
  {
  // 访问数据库,返回一个邮件地址集合
  }
  }

  当把JunkMail设计好了以后,再调用JunkMail类完成邮件的发送,将是非常轻松的事情。 如果说传统的面向过程的编程是符合机器运行指令的流程的话,那么面向对象的思维方法就是符合现实生活中人类解决问题的思维过程。 在面向对象的软件分析和设计的时候,要提醒自己,不要一上来就去想程序代码的实现,应该抛开具体编程语言的束缚,集中精力分析我们要实现的软件的业务逻辑,分析软件的业务流程,思考应该如何去描述和实现软件的业务。毕竟软件只是一个载体,业务才是我们真正要实现的目标。 但是在设计过程中,心里却往往在担心,如果我完全不去考虑程序代码的实现的话,那么我怎么知道我的设计一定合理呢?我怎么知道我设计的类、接口一定可以实现呢?所以经常可以看到的现象就是: 在设计过程中,虽然知道不能过早考虑代码实现,但是每设计一个类,一个接口,心里都要不知不觉的用自己熟悉的编程语言大概的评估一下,看看能否编出来,因此,一不小心,就会又回到按照程序功能实现的思路进行设计的老路上去了。 举个例子来说明,在做Web程序设计的时候,经常要遇到分页显示数据的情况。比如说需要把系统中所有的用户都列出来这样的功能。假设使用User类来表示用户,增加用户addUser(),删除用户deleteUser(),查询所有用户listUsers()方法。而数据库中有一个user表,一条记录是一个用户的信息。下面考虑一下User类的方法的实现: addUser()和deleteUser()方法都好实现,就是对数据库增加记录和删除记录。对于listUsers()方法,其实就是对user表的select,取出一个记录集。但是该怎么从listUsers()方法中得到所有用户的列表呢? 一个方法调用的返回值只有一个,没有多个,所以很多情况下采用的办法就是返回值定义为集合类型,比如Vector。这样就可以在listUsers()方法的具体代码实现的时候,从数据库依次取出一个个记录,插入到Vector里面来。在主程序里面,调用listUsers()方法可以返回一个Vector,然后再对Vector遍历操作,就可以得到用户列表了。

 


 public class User
  {
  public static void addUser(...)
  {
  // 数据库insert一条记录
  }
  public static void deleteUser(...)
  {
  // 数据库delete一条记录
  }
  public Vector listUsers(...)
  {
  // 数据库select结果放到一个集合里面
  }
  }

  这样的设计基本合理,但是仍然有点小问题。因为在设计的时候,就考虑到了用Java的集合类Vector来实现对不定长数据集的存放,因而违反了面向对象设计的一个原则:在设计的时候不应过早的考虑具体程序语言的实现。所以必须用抽象的方法,和具体实现无关的方法来表达业务逻辑。 我们知道,通常对具有集合特征的数据结构进行遍历通常可以使用next和hasNext方法,next实现取下一个用户,hasNext判断是否还有元素。 因此我们定义一个接口Iterator,这个接口中定义两个方法next和hasNext:

 


 public interface Iterator
  {
  public boolean hasNext()
  {
  }
  public Object next()
  {
  }
  }

  而User类的listUses方法返回值

  改为Iterator接口的实现类:


 public class User
  {
  ...
  public Iterator listUsers()
  {
  }
  ...
  }

  这样就把User类的设计和具体的实现方法分离开了,因为此时任何实现了next()和hasNext()方法的类都可以做为listUsers的返回值,都可以被用来表达“用户列表”,而不仅仅可以使用Vector而已。 比如,我可以用ArrayList来表达用户列表,因为ArrayList也实现了Iterator,当然我也可以自己专门写一个类来存放用户列表,只要实现next()和hasNext()方法就行了。 这样在具体的编写代码的时候,程序员具有了最大的灵活性,可以根据具体的情况,采用不同的编程方法来存放用户列表。特别是降低了程序的耦合度,提高了程序的可移植性。对于上面那个JunkMail的listAllMail()方法也同样应该改为接口类型。 然后,在主程序里面就这样来使用User类的listUsers方法:


  User myUser = new User();
  Iterator iterator = myUser.listUsers();
  while (iterator.hasNext())
  {
  iterator.next();
  }

  这样就可以完全不用考虑程序代码实现了,从高层次上把功能抽象出来,定义成为接口,同时又可以把系统设计的很合理,完全根据业务的需求来进行设计。 结语 通过上面的几个例子的设计说明,使用面向对象的思维方法,其实是一个把业务逻辑从具体的编程技术当中抽象出来的过程,而这个抽象的过程是自上而下的,非常符合人类的思维习惯,也就是先不考虑问题解决的细节,把问题的最主要的方面抽象成为一个简单的框架,集中精力思考如何解决主要矛盾,然后在解决问题的过程中,再把问题的细节分割成一个一个小问题,再专门去解决细节问题。 因而一旦牢牢的抓住了这一点,你就会发现在软件设计和开发过程中,你自己总是会不知不觉的运用面向对象的思维方法来设计和编写程序,并且程序的设计和开发也变得不再那么枯燥,而一个合理运用面向对象技术进行设计和架构的软件,更是具备了思维的艺术美感。最后,愿面向对象的思维方法也能给您的程序设计之路带来创作的乐趣。

探秘Servlet 3.0中的Web安全改进

分类:J2EE  来源:网络  时间:2010-10-21 23:36:17

  Servlet 3.0最为最新的Servlet最新标准,其提供了很多新特性,比如异步请求处理、声明式语法支持等。在这里我们将考察Servlet 3.0安全方面的增强。

  对网站进行跨站攻击最常用的一个手段就是在网页中插入恶意的Html和JavaScript代码。一旦你的网页被增加这些恶意代码,那么就非常容易泄流你的个人信息,比如Cookie。

  Cookie作为保留会话状态的手段,经常被用来保存用户登录信息等敏感性数据,但是由于Cookie既可以在服务器端读取,又可以在客户端通过脚本读取,则导致其成为Web应用安全的一个薄弱环节。

  在2002年,微软采用了一种被称为“HttpOnly Cookies”的技术,来防止恶意读取Cookie信息。该技术实际并不复杂,只是在Cookie上增加一个额外的属性,在浏览器支持的情况下,如果尝试通过脚本读取Cookie内容,返回结果将为空。现在大多数服务器和客户端都采用的是这种技术,当然浏览对对XMLHttpRequest对象进行了特殊处理。

  在Servlet 3.0规范中,Java Servlet开始支持“HttpOnly Cookies”。当使用HttpServletResponse的addCookie方法,向浏览器提供Cookie的时候,可以通过Cookie对象的setHttpOnly方法指定Cookie为HttpOnly。例如:


Cookie cooki=new Cookie("user_name","guandeliang");   
cooki.setMaxAge(60*60*24*365);   
cooki.setPath("/");   
cooki.setHttpOnly(true);   
response.addCookie(cooki);  

  另外,如果希望判断一个Cookie对象是否是HttpOnly,可以通过调用该对象的isHttpOnly()进行判断。

Java几个过滤器学习技巧

分类:J2EE  来源:网络  时间:2010-10-21 23:30:58


 import javax.servlet.*;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  /**
  * 用于的使 Browser 不缓存页面的过滤器
  */
  public class ForceNoCacheFilter
  implements Filter
  {
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException
  {
  ((HttpServletResponse) response).setHeader("Cache-Control","no-cache");
  ((HttpServletResponse) response).setHeader("Pragma","no-cache");
  ((HttpServletResponse) response).setDateHeader ("Expires", -1);
  filterChain.doFilter(request, response);
  }
  public void destroy()
  {
  }
  public void init(FilterConfig filterConfig) throws ServletException
  {
  }
  }
  import javax.servlet.*;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  import java.util.List;
  import java.util.ArrayList;
  import java.util.StringTokenizer;
  import java.io.IOException;
  /**
  * 用于检测用户是否登陆的过滤器,如果未登录,则重定向到指的登录页面
  * 配置参数
  * checkSessionKey 需检查的在 Session 中保存的关键字

  * redirectURL 如果用户未登录,则重定向到指定的页面,URL不包括 ContextPath

  * notCheckURLList 不做检查的URL列表,以分号分开,并且 URL 中不包括 ContextPath

  */
  public class CheckLoginFilter
  implements Filter
  {
  protected FilterConfig filterConfig = null;
  private String redirectURL = null;
  private List notCheckURLList = new ArrayList();
  private String sessionKey = null;
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException
  {
  HttpServletRequest request = (HttpServletRequest) servletRequest;
  HttpServletResponse response = (HttpServletResponse) servletResponse;
  HttpSession session = request.getSession();
  if(sessionKey == null)
  {
  filterChain.doFilter(request, response);
  return;
  }
  if((!checkRequestURIIntNotFilterList(request)) && session.getAttribute(sessionKey) == null)
  {
  response.sendRedirect(request.getContextPath() + redirectURL);
  return;
  }
  filterChain.doFilter(servletRequest, servletResponse);
  }
  public void destroy()
  {
  notCheckURLList.clear();
  }
  private boolean checkRequestURIIntNotFilterList(HttpServletRequest request)
  {
  String uri = request.getServletPath() + (request.getPathInfo() == null ? "" : request.getPathInfo());
  return notCheckURLList.contains(uri);
  }
  public void init(FilterConfig filterConfig) throws ServletException
  {
  this.filterConfig = filterConfig;
  redirectURL = filterConfig.getInitParameter("redirectURL");
  sessionKey = filterConfig.getInitParameter("checkSessionKey");
  String notCheckURLListStr = filterConfig.getInitParameter("notCheckURLList");
  if(notCheckURLListStr != null)
  {
  StringTokenizer st = new StringTokenizer(notCheckURLListStr, ";");
  notCheckURLList.clear();
  while(st.hasMoreTokens())
  {
  notCheckURLList.add(st.nextToken());
  }
  }
  }
  }
  import javax.servlet.*;
  import java.io.IOException;
  /**
  * 用于设置 HTTP 请求字符编码的过滤器,通过过滤器参数encoding指明使用何种字符编码,用于处理Html Form请求参数的中文问题
  */
  public class CharacterEncodingFilter
  implements Filter
  {
  protected FilterConfig filterConfig = null;
  protected String encoding = "";
  public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException
  {
  if(encoding != null)
  servletRequest.setCharacterEncoding(encoding);
  filterChain.doFilter(servletRequest, servletResponse);
  }
  public void destroy()
  {
  filterConfig = null;
  encoding = null;
  }
  public void init(FilterConfig filterConfig) throws ServletException
  {
  this.filterConfig = filterConfig;
  this.encoding = filterConfig.getInitParameter("encoding");
  }
  }

Servlet中实现四位数字验证码

分类:J2EE  来源:网络  时间:2010-10-21 23:29:03

  以下为在Servlet中实现四位数字验证码的源码分析。 import java.awt.image.*;

  


      import com.sun.image.codec.jpeg.*;
  import javax.servlet.*;
  import javax.servlet.http.*;
  import java.io.*;
  import java.util.*;
  import java.awt.*;
  /*
  * 功能:调用AuthCodeServlet可以生成一个4位数字的验证码图片,验证码的图片宽度和高度可以通过配置文件进行定义
  * 验证码调用格式为: /servlet/AuthCodeServlet?w=78&h=32
  * 或者使用默认长宽/servlet/AuthCodeServlet
  */
  public class AuthCodeServlet extends HttpServlet {
  // 处理post
  public void doPost(HttpServletRequest req,HttpServletResponse res)
  throws ServletException,IOException {
  doGet(req,res);
  }
  //设置字体
  private Font mFont=new Font("Times New Roman", Font.PLAIN,16);
  public void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException {
  HttpSession session=request.getSession();
  response.setContentType("image/gif");
  response.setHeader("Pragma","No-cache");
  response.setHeader("Cache-Control","no-cache");
  response.setDateHeader("Expires", 0);
  int width=70; //验证码默认长度
  int height=24; //验证码默认宽度
  if(request.getParameter("w")!=null && !request.getParameter("w").equals(""))
  width = Integer.parseInt(request.getParameter("w"));
  if(request.getParameter("h")!=null && !request.getParameter("h").equals(""))
  height = Integer.parseInt(request.getParameter("h"));
  ServletOutputStream out=response.getOutputStream(); //获取输出流
  BufferedImage image=new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB); //新建验证图片,并设置验证码图片的大小
  Graphics gra=image.getGraphics(); //获取图形上下文
  Random random=new Random();
  gra.setColor(getRandColor(260,210)); //设置验证码的图片背景色
  gra.fillRect(0,0,width,height);
  gra.setColor(Color.BLUE); //设置字体色为蓝色
  gra.setFont(mFont); //设置定义的字体格式
  // 随机产生254条干扰直线,使图象中的验证码不易被解析程序分析到
  gra.setColor(getRandColor(110,240));
  for (int i=0;i<254;i++)
  {
  int x = random.nextInt(width);
  int y = random.nextInt(height);
  int xl = random.nextInt(63);
  int yl = random.nextInt(64);
  gra.drawLine(x,y,x+xl,y+yl);
  }
  // 取随机产生的验证码(4位数字)
  String sRand="";
  for (int i=0;i<4;i++){
  String rand=String.valueOf(random.nextInt(353));
  sRand+=rand;
  // 将认证码显示到图象中
  gra.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
  //调用随机函数构建随机颜色三素
  gra.drawString(rand,13*i+6,16);
  }
  session.setAttribute("authCode",sRand);
  JPEGImageEncoder encoder=JPEGCodec.createJPEGEncoder(out);
  encoder.encode(image);
  }
  static Color getRandColor(int ff,int cc){
  //给定范围获得随机颜色
  Random random = new Random();
  if(fc>255) ff=255;
  if(bc>255) cc=255;
  int r=ff+random.nextInt(cc-ff);
  int g=ff+random.nextInt(cc-ff);
  int b=ff+random.nextInt(cc-ff);
  return new Color(r,g,b);
  }
  static public String getAuthCode(HttpSession session){
  //返回验证码
  return (String)session.getAttribute("AuthCode");
  }
  }

 

  • 60
  • |<
  • <<
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • >>
  • >|