岁月悠悠 http://blog.tom.com/hoohey zh newblog.tom.com RSS <![CDATA[ Tomcat问题 ]]> http://blog.tom.com/hoohey/article/1579.html
把今天的状况总结一下，如果以后谁遇到了类似的情况，还可以参考一下，节约时间。
   用Tomcat，启动服务器时，遇到报错为如下消息：
信息：The Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: D:Program FilesJavajre1.5.0_09bin;.;C:WINDOWSsystem32;C:WINDOWS;C:WINDOWSsystem32;C:WINDOWS;C:WINDOWSSystem32Wbem;C:Program FilesATI TechnologiesATI Control Panel;C:Program FilesMicrosoft SQL Server80ToolsBINN;C:Program FilesMicrosoft SQL Server90Toolsbinn;C:Program FilesCommon FilesAdobeAGL;C:Program FilesMicrosoft Visual Studio .NET 2003SDKv1.1Bin;C:WINDOWSMicrosoft.NETFrameworkv1.1.4322;D:Program FilesJavajdk1.5.0_09bin;.
2007-3-7 17:18:12 org.apache.coyote.http11.Http11BaseProtocol init
严重：Error initializing endpoint
这时的解决措施可以是：去下载一个tcnative-1.dll文件，放在C:WINDOWSsystem32里，再重新启动服务器，看服务器是否能正常启动。
如果服务器启动时，没有报前面的错，而是报出另外的错误，如以下信息：
严重: An incompatible version 1.1.1 of the Apache Tomcat Native library is installed, while Tomcat requires version 1.1.3
2007-3-7 17:39:33 org.apache.catalina.core.AprLifecycleListener lifecycleEvent
信息: An older version 1.1.1 of the Apache Tomcat Native library is installed, while Tomcat recommends version greater than 1.1.4
这说明tcnative-1.dll文件版本太低，需下载一个高于1.1.4版本的文件。
你可以下载http://tomcat.heanet.ie/native/1.1.8/binaries/win32/ tcnative-1.dll  该.dll文件为1.1.8版本。
至于文件放的位置有两种选择，
1、把文件放入C:WINDOWSsystem32里。我就是这样解决的。
2、把它放在环境变量path中所指向的jdk的bin的目录下，例如，放在C: Javajdk1.5.0_09bin目录下。

]]> 2007-04-23 18:21:11 <![CDATA[ struts多模块 ]]> http://blog.tom.com/hoohey/article/1578.html 这两天网站才刚开始做,刚开始做就碰到一个问题,因为用的是struts+hibernate,前台和后台我给做成多模块的,多摸块出现了一个问题,就是我的action找不到mapping,找了很久才发现原因:
 
ModuleConfig mc = (ModuleConfig)application.getAttribute(Globals.MODULE_KEY+"/moduleName");
request.setAttribute(Globals.MODULE_KEY,mc);
 
如果不加这句,它不会到指定的模块配置文件里去找,只是到默认的模块里找.那么Globals.MODULE_KEY就是默认的/根目录模块,所以始终无法在struts-config-module.xml里找到对应的action的Path.只是在struts-config.xml里找,但是如果你在用超链接的话因为${pageContext.request.contextPath}/module/action.do,加了module所以能找到,我就是因为这个原因一直认为可以找到对应的struts-config-module.xml文件,所以郁闷了很久.....问题解决了 ]]> 2007-03-26 15:25:00 <![CDATA[ Linux基本命令 ]]> http://blog.tom.com/hoohey/article/1577.html 简单罗列一些总结


 1、linux做JAVA开发
   unix:sun:solaris/Hp:hp-ux/ibm:aix 都在做UNIX操作系统（收费）内核都不一样
      freebsd/openbsd/netbsd(免费)
   linux:redhat /suse /ul  各厂商内核是一样的,现在内核到2。6了
    Redhat:个人版7.2 7.3 8 9
      企业版:as 2.1 3 4
    
    安装:cdrom 硬盘 网络:(nfs/http/ftp) 无人制:kickstart
    虚拟:vmware/vpc(tools)
    基本命令:
    远程管理工具：命令行工具:telnet 23端口(同windows)    ssh:secure shell
    图形界面:vnc
    配置JAVA环境：安装JDK tomcat/weblogic/jboss
    安装方法：源码安装 二进制安装：rpm:redhat package/management
    命令：
    [root@localhost soft]#rpm -ivh jdk-1_5_0_06-linux-i586.rpm
    //i:install v:verbose h:hash、
--1.1 Linux系统文件结构
      /bin:所有用户都可以使用的命令所在位置（系统默认的命令）
       用户：普通用户， 管理员用户(root)
      /sbin:只有管理员可以使用的命令
      /boot:内核所在的位置
      /dev:设备文件所在目录 /dev/sda /dev/hda
      /etc:配置文件所在目录
      /home:用户主目录(包括用户的配置文件信息，用户登录后最先目录)
      /initrd:虚拟设备
      /lost+found:回收站
      /lib:库目录
      /mnt:光盘或软盘的加载点 ，通过mount命令来加载
      /opt:第三方软件安装目录
      /root:root帐号主目录
      /tmp:临时文件
      /usr:用户目录：用户安装的文件
      /var:保存的文件大小不确定的（日志文件、邮件、。）
--1.2Linux命令集
  --1.2.1 Linux基本命令
      1)IP地址设置：netconfig 设置完了以后用service network restart
      2)显示IP地址：ifconfig
      3)修改分辨率: redhat-config-xfree86
      4)关机:init 0
      5)显示当前目录：pwd
      6)显示目录内容：ls //list(dir)黑色：表示文件 兰色表示：目录
        ls -l//cd显示详细信息，-代表文件  d:表示directory
      7)生成目录：mkdir  (make directory) e.g:mkdir /testl
      8)进入目录: cd /dirname  e.g:cd /zb 进入文件夹
      8)拷贝文件：cp e.g:cp /etc/yp.conf .  //拷贝到当前目录
      9）删除：rm -rf  [filename or dirname]
  rm:remove r:可以删除目录 f:不需要确认
      10)移动或改名:mv  e.g: mv 1.txt 2.txt(改名)  只有移动到另一目录才是移动 e.g: mv 1.txt abc
      11)文件编辑命令：vi
 1、命令模式  esc
 2、插入模式  i
 3、末行模式  :
       #vi filename
       命令---插入 i
       插入---命令 esc
       命令模式---末行模式:wq  q!不存盘退出 wq!强制存盘
       查看内容：cat filename
       查找命令：/内容   n向下查  N向上查
       ***命令模式下
         删除一行：dd
         复制一行：yy
         粘贴：p
         撤消：u
       ***末行模式下
       　显示行号：set nu
         统计文件的行数:wc -l filename
       查找文件：find dirname -name "keyword"
       e.g:find /etc -name "*.conf" (查找etc目录下的所有.conf扩展名的文件，-name表示根据名字查找)
  对文件内容做查找操作，找含有特定关键字的所有行:grep
   e.g:grep root /etc/passwd (在passwd文件中查找含有root关键字的所有行)
 
      12)自动补齐命令键：tad　e.g：mkd以后你按tab键，会给你谈出所有相关命令
      13)ftp lftp gftp
      14)对输出结果排序,不影响原文件：sort filename  反向排序 sort -r filename
      15)对结果去点连续重复的行，不影响原文件：uniq filename
      16)新建空文件：touch filename
      17)改变文件的所有者：chown username:groupname filename 
      e.g: chown root:zb /home/zb/f4
  改变组:chgrp groupname filename
  查看文件所有者：ls -l
      18)软件包管理(类似WINDOWS下的添加删除程序):redhat-config-packages
 
  --1.2.2 Linux下java使用
      1)设置ＪＡＶＡ环境　修改配置文件/etc/profile  e.g:vi /etc/profile
        环境变量是区分大小写的，路径是冒号分隔，（windows下是分号）
        配置好以后让它立即生效的话用：soruce /etc/profile  (重起系统也可以)
　　 　2)压缩文件：.gz .bz2  .rar  .zip
        e.g: unzip ja....zip  (unzip解压。）
　　　 3)安装Tomcat 进入到bin目录，执行添加权限操作：chmod u+x *  给所有文件执行权限
        bin/startup.sh  (这是tomcat的启动，windows下是.bat文件)
     
  --1.2.3用户管理
      1)用户信息存在/etc/passwd文件下
        查看用户信息:cat /etc/passwd
      2)创建用户: useradd username
      3)切换用户:su - username
      4)设置密码：passwd username  管理员使用
         passwd 个人用户自己修改自己密码
      5)删除用户：userdel username    只删除用户 在/home下还有用户目录
         userdel -r username 删除用户和用户主目录
      6)查看当前用户：whoami
      7)查看用户信息：id username
      8)查看已经登录的用户:who
      9)伪终端：pts/0
 
  --1.2.4 telnet服务
      1、cd /etc/xinetd.d
      2、vi krb5-telnet
         把disable = yes 改为no
      3、重复xinetd服务，是一个管理服务 service xinetd restart
      4、cnkconfig --list查看列表
 
  --1.2.5 打包归档命令 tar
      打包：tar -cvf filename.tar filelist(*.conf)
      e.g:tar -cvf 1.tar filename1 filename2
 展开：tar -xvf filename.tar
 e.g:tar -xvf 1.tar
    tar命令不做压缩操作，如果要压缩的话得用到压缩工具：gzip bzip2
     gzip filename: 压缩后的文件是filename.gz
     bzip2 filename:filename.bz2
     解压：
     gzip -d filename.gz
     bzip2 -d filename.bz2
     如果要又压缩，又打包：tar -czvf filename.tar.gz filelist
     解压：tar -xzvf filename.tar.gz
   
  --1.2.6 Linux下MYSQL安装
     1、通过光盘安装：redhat-config-packages 系统盘安装
 
     2、下载mysql.tar.gz
     3、# tar -xzvf mysql
       # useradd mysql

    /**
     *   这几步是出于安全考虑
     *
        scripts/mysql_install_db --user=mysql
        chown -R root mysql-max-5.0.11-beta-linux-i686
        chown -R mysql data
        chgrp -R mysql mysql-max-5.0.11-beta-linux-i686
     */
    
     4、/bin/safe_mysqld --user=mysql :运行

]]> 2007-03-04 13:56:02 <![CDATA[ JavaMail ]]> http://blog.tom.com/hoohey/article/1574.html 时间:2006-12-10~~~~2006-12-11

学了两天,能写个发送程序....JavaMail
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
public class MsgSender {
 public static void main(String[] args) throws MessagingException {
  // TODO Auto-generated method stub
  Properties prop = new Properties();
  prop.setProperty("mail.transport.protocol","smtp");
  prop.setProperty("mail.host","192.168.1.200");
  prop.setProperty("mail.smtp.auth","true");
  Authenticator auth = new Authenticator(){
   @Override
   protected PasswordAuthentication getPasswordAuthentication(){
    return new PasswordAuthentication("hoohey","111111");
   }
  };
  String body = "<a href=http://www.layzo.com>" +
       "欢迎点击进入我们的网站</br></a>"+
         "<img src="cid:image">";
  String subject ="Test图片";
  Session session = Session.getInstance(prop,auth);
  session.setDebug(true);
  
  MimeMessage msg = new MimeMessage(session);
  msg.setFrom(new InternetAddress("fool@tom.com"));
  msg.setRecipients(Message.RecipientType.TO,InternetAddress.parse("zhongbin82@126.com"));
  //如果是简单的邮件,InternetAddress.parse("zhongbin82@126.com")直接用"zhongbin82@126.com"代替就可以
  msg.setSubject(subject);
  
  MimeMultipart multipart = new MimeMultipart("related");
  MimeBodyPart htmlBodyPart = new MimeBodyPart();
  htmlBodyPart.setContent(body,"text/html;charset=gb2312");
  multipart.addBodyPart(htmlBodyPart);
  
  MimeBodyPart gifBodyPart = new MimeBodyPart();
  FileDataSource fds = new FileDataSource("d:/My Pictures/011ak.jpg");
  gifBodyPart.setDataHandler(new DataHandler(fds));
  gifBodyPart.setHeader("Content-Location","image");
  multipart.addBodyPart(gifBodyPart);
  
  msg.setContent(multipart);
  msg.saveChanges();
  
  Transport.send(msg);
 }
}
]]> 2006-12-13 16:30:54 <![CDATA[ Hibernate初探 ]]> http://blog.tom.com/hoohey/article/1573.html 时间:2006-12-07~~~~2006-12-11
  
这一周是学Hibernate,由于上一次JDBC 没及时更新,这一周也接不上,拉下太多,导致现在不可能从头一篇篇写,这周也有两天是学JavaMail,总体来说,Hibernate好象简单一些,这里只是把自己写的一个Hibernate登陆程序贴一下,懒,改天空闲复习的时候在仔细写几篇:
/**    
 *用Hibernate进行用户注册及登录练习
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import hoohey.User;//我包里的一个持久类
public class HqlTest {
 public static void main(String[] args) {
  String username = null;
  String password = null;
  Configuration cfg = new Configuration();
  cfg.addResource("User.hbm.xml");
  BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
  Session session = null;
  System.out.println("登录请按1,注册用户请按2！");
  Scanner in = new Scanner(System.in);
  String pos = in.nextLine();
  if(pos.equals("1")){
   try {
   
    System.out.println("请输入您的用户名：");
    username = reader.readLine();
   
    System.out.println("请输入您的密码：");
    password = reader.readLine();
   
   } catch (IOException e) {
    e.printStackTrace();
    }
  }
  else if(pos.equals("2")){
   String newusername=null;
   String newuserpsw =null;
   try {
    System.out.println("请输入您的用户名：");
    newusername = reader.readLine();
    System.out.println("请输入您的密码：");
    newuserpsw = reader.readLine();
   } catch (IOException e) {
    e.printStackTrace();
   }
   SessionFactory factory = cfg.buildSessionFactory();
   session = factory.getCurrentSession();
   
   User u = new User();
   u.setUsername(newusername);
   u.setPassword(newuserpsw);
   
   session.beginTransaction();
   session.saveOrUpdate(u);
   session.getTransaction().commit();
   System.out.println("恭喜您,注册成功!");
   return;
  }
  else {
   System.out.println("您将退出!");
   System.exit(1);
  }
  try {
   SessionFactory factory = cfg.buildSessionFactory();
   
   session = factory.getCurrentSession();
   
   session.beginTransaction();
   Query q = session.createQuery("from vo.User as User where User.username=  and User.password= ");
   
   q.setString(0,username);//注入第一个 号的值,Hibernate中是0，而JDBC是从1开始.
   q.setString(1,password);
   
   List l = q.list(); //将取的的结果存入List
   Iterator it = l.iterator(); //List产生一个进行迭代器, 下面进行迭代
   User u = null;
   if(it.hasNext()){
    System.out.println("登录成功!");
    u = (User)it.next();
   }else
   {
    System.out.println("用户名或密码有误!");
    System.exit(1);
   }
   session.getTransaction().commit();
   //因为是currentSession,确保只有一个session,所以commit自动关闭，无需close().
   
   System.out.println("修改用户名请按1,修改密码请按2！");
   String num = reader.readLine();
   if(num.equals("1")){
   System.out.println("填入您的新用户名：");
   String newUser = reader.readLine();
   u.setUsername(newUser);
  
   session = factory.getCurrentSession();
   session.beginTransaction();
   session.saveOrUpdate(u);
   session.getTransaction().commit();
   System.out.println("用户名修改成功!");
   }
   else if(num.equals("2"))
   {
   System.out.println("填入您的新密码：");
   String newPw = reader.readLine();
   u.setPassword(newPw);
   
   session = factory.getCurrentSession();
   session.beginTransaction();
   session.saveOrUpdate(u);
   session.getTransaction().commit();
   System.out.println("密码修改成功!"); 
   }
   else{
    System.exit(1);
   }
   
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  
  
 }
}

 
还有个Demo,对数据库进行操作(hibernate)
import hoohey.User;
import java.sql.Timestamp;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class Demo{
 
 public static void main(String[] args){
  Configuration cfg = new Configuration();
  cfg.addClass(User.class);
//  **上面可以cfg.addResource("hoohey/User.hbm.xml"),所以.hbm.xml也是可以改名字的(路径/文件名.xml)
//  也可以在配置文件seesion-factory加<mapping resource="映射文件",那样的话该行要省略
  
  cfg.configure("hoohey/hibernate.xml");
//  如果是引入hibernate.properties文件,这句话就不需要
//  **如果.cfg.xml文件改了名字的话要在上面这句括号里("路径/文件名.xml")
  
  Session session = null;
  
  try {
   SessionFactory factory = cfg.buildSessionFactory();
   session =factory.openSession();
/***********************查找一条纪录**********************/    
   User u = (User)session.load(User.class,new Integer(2));
   System.out.println("UserName:"+u.getUsername());
/***********************增加一条纪录**********************/   
/*   User u =new User();
   u.setUsername("bibobi");
   u.setPassword("bibobi");
   u.setLogintimes(new Integer(1));
//上句将这个设成Integer是有原因的，如果上面这句没有，而logintimes是int型的话，就算你只查入username也会往数据库插一个0值，而Integer不会
   u.setLogintime(new Timestamp(System.currentTimeMillis()));
   session.beginTransaction();
   session.save(u);
   session.getTransaction().commit();*/
/***********************修改一条纪录**********************/ 
/*   User u = (User)session.load(User.class,new Integer(7));
   u.setUsername("j2ee");
   
   session.beginTransaction();
   session.update(u);  //also could use save(u)
   session.getTransaction().commit();*/
   
/***********************删除一条纪录**********************/
/*   User u = (User)session.load(User.class,new Integer(10));
   session.beginTransaction();
   session.delete(u);
   session.getTransaction().commit(); */
   
   
  } catch (HibernateException e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally{
   if(session!=null){
   session.close();
   session = null;
   }
  }
  
 }
}
 
大部分Hibernate的内容都有体现,Hibernate重要知识点:
两大知识点，对象三种状态及主键
      临时状态 脱管状态 持久状态
0、知道如何在不使用默认文件名时，也能配置Hibernate
如果在配置文件中加了<maping 映射文件>那么可以不用再addClass
     掌握SessionFactory和Session在编程时应该注意什么问题。
1、对象的三种状态分别是什么？有什么含义？
2、update方法与merge方法的区别，应用场合分别是什么？
3、saveOrUpdate方法应用场合？什么时候执行save 什么时候执行update 
unsaved-value
4、主键生成器是什么意思？为什么实体一定要有标识符？
　如果数据库表中没有主键，能否映射对象？
5、HQL，Hibernate Query Lange，要求必须要非常熟练地掌握

]]> 2006-12-13 16:18:25 <![CDATA[ JDBC第六天 ]]> http://blog.tom.com/hoohey/article/1572.html
西风烈，长空雁叫霜晨月。
霜晨月，马蹄声碎，喇叭声咽。
雄关漫道真如铁，而今迈步从头越。
从头越，苍山如海，残阳如血。
       ---李敖
趁中午休息时间，读了李大师的几首诗，甚是感动，虽然不太喜欢他狂妄、目空一切的个性，但是这些东西正是我缺之又缺的，
一个人要想成点事，自信是必不可少的，那么就有所改变吧！从头越，苍山如海，残阳如血....你体会到了么....
 
时间 ：2006-12-05  内容 ：行集、离线结果集、ORM

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));//这个reader 也是要关闭的

一个结果集处理小demo(步骤详细说明)
public class Demo {
 public static String filter(String str) {
  return str.replaceAll("'", "''");
 }
 public static void main(String[] args) {
  /*
   * 事先声明连接、语句、结果集，为了可以在finally中关闭资源
   */
  Connection conn = null;
  PreparedStatement stmt = null;
  ResultSet rs = null;
  
  BufferedReader reader = null;
  
  String username = null, password = null;
  try {
   System.out.println("请输入用户名：");
   byte[] buf = new byte[128];
   int len = System.in.read(buf);
   username = new String(buf, 0, len
     - System.getProperty("line.separator").length());
   System.out.println("请输入密码：");
   len = System.in.read(buf);
   password = new String(buf, 0, len
     - System.getProperty("line.separator").length());
  } catch (IOException e1) {
   e1.printStackTrace();
  }
  if (username == null || password == null) {
   System.out.println("用户名、密码不能为空！");
   System.exit(1);
  }
  try {
   // 第一步，加载驱动程序
   
   Class.forName("com.mysql.jdbc.Driver");
   // 第二步，由DriverManger获取连接
   conn = DriverManager.getConnection(
     "jdbc:mysql://localhost:3306/j2ee", "root", "root");
   conn.setAutoCommit(false);
   // 第三步，由连接生成语句
   String sql = "select * from users where username=  and password= ";
   stmt = conn.prepareStatement(sql,
     ResultSet.TYPE_SCROLL_INSENSITIVE,
     ResultSet.CONCUR_UPDATABLE);
   stmt.setString(1, username);
   stmt.setString(2, password);
   // 第四步，执行语句，并生成结果集
   rs = stmt.executeQuery();
   // 第五步，对结果集进行迭代
   if (rs.next()) {
    System.out.println("Welcome!");
    System.out.println("请输入新密码：");
  
    /**********************使用结果集修改记录***********************
     *
     **********************************************************/
    reader = new BufferedReader(
      new InputStreamReader(System.in));
    String newPw = reader.readLine();
    //首先，更新要修改字段值
    rs.updateString("password", newPw);
    
    //其次，一定要将修改的结果提交
    rs.updateRow();
    
    /****************使用结果集插入记录**********************
     *
     ****************************************************/
    System.out.println("请输入新用户名：");
    String newUser = reader.readLine();
    System.out.println("请输入新用户名密码：");
    String newUserPw = reader.readLine();
        //首先，要将游标移动到可插入记录的位置
    rs.moveToInsertRow();
    //其次，修改插入记录的位置上的各个字段值
    rs.updateString("username", newUser);
    rs.updateString("password", newUserPw);
    rs.updateTimestamp("loginTime", new Timestamp(System.currentTimeMillis()));
    //第三，插入记录
    rs.insertRow();
    //最后，再将游标移回到原来的位置上。
    rs.moveToCurrentRow();
    System.out.println("insert successfully!");
    
    /************************使用结果集删除记录*******************
     *
     ***********************************************************/
    //首先，将游标移动到要删除记录的位置
    System.out.println("请输入删除行号：");
    String num = reader.readLine();
    rs.absolute(Integer.parseInt(num));
    
    //第二，删除记录，无须指明删除条件
    rs.deleteRow();
    System.out.println("删除成功!");
   } else {
    System.out.println("Failed!");
   }
   conn.commit();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (Exception e) {
   e.printStackTrace();
   try {
    conn.rollback();
   } catch (SQLException e1) {
    e1.printStackTrace();
   }
  } finally {
   // 第六步，关闭所有资源，并保证每个资源的关闭至少被执行一次
   try {
    if (rs != null) {
     rs.close();
     rs = null;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   }
   try {
    if (stmt != null) {
     stmt.close();
     stmt = null;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   }
   try {
    if (conn != null && !conn.isClosed()) {
     conn.close();
     conn = null;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   }
   try {
    if(reader!=null) {
     reader.close();
     reader = null;
    }
   } catch (IOException e) {
    e.printStackTrace();
   }
  }
 }
}

剩下的行集及离线结果集就看同学的链接吧，因为这两天是我没掌握好的!
袁彬的BLOG,没经过他同意,见谅啊
http://blog.csdn.net/ecaterina/archive/2006/12/06/1432161.aspx

]]> 2006-12-13 16:05:46 <![CDATA[ JDBC第五天 ]]> http://blog.tom.com/hoohey/article/1571.html

时间：2006-12-04 
内容:1、SQL注入攻击
    2、PreparedStatement用法，为什么要用它而不用Statement
    3、ResultSet的三种属性，含义，用法
 
■SQL注入:初学者很容易犯的一个错误，就是在登陆的时候，一般验证是通过查询表select * from users where username =   and password =  来查询，这样的话如果不做处理，很可能导致恶意登陆，即在第一个 (用户)处加' or '1'='1' or '1'='1 或者在第二个 (密码)处加 ' or '1'='1' ；
这就叫Sql注入,那么如何防止出现这种错误呢？下面写个程序来说明一下：
 
import java.io.*;
import java.sql.*;
public class Demo{
 public static void main(String[] args ) throws ClassNotFoundException{
  Connection conn = null;
  Statement stmt = null;
  ResultSet rs = null;
  String username = null;
  String password = null;
  
  try {
   System.out.println("请输入帐号：");
   BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
   username = reader.readLine();
   System.out.println("请输入密码：");
   password = reader.readLine();
  } catch (IOException e1) {
   e1.printStackTrace();
  }
  
  Class.forName("com.mysql.jdbc.Driver");
  try {
   Class.forName("com.mysql.jdbc.Driver");
   conn = DriverManager.getConnection("jdbc:mysql:///test user=root&password=");
   stmt = conn.createStatement();
   String sql = "select * from users where username='"+username+"' and password='"+password+"'";
   //String sql = "select * from user where name='" + username.replaceAll("'","''") +
   //         "' and password='" + password.replaceAll("'","''") + "'";
   rs = stmt.executeQuery(sql);
   if (rs.next())
    System.out.println("登录成功!");
   else
    System.out.println("失败！");
   conn.close();
  } catch (SQLException e) {
   
   e.printStackTrace();
  }
 }
}
如果这段程序不做处理的话，就会导致SQL注入.但是可以用注解部分的那句sql，该句进行了转义，通过''来进行转义，它其实代表一个'
由此也导出PreparedStatement，PreparedStatement 可以避免这种情况的产生，而且它还比Statement 有以下几个优点：
1、可以动态设参数
2、Statement是拿过SQL语句再来编译，如果执行很多行的话，同一条语句也要重复执行，消耗资源；而PreparedStatement相同的只执行一次，然后
等待参数的输入再执行。
3、参数传递,会自动转义，防止SQL注入攻击，可以根据数据类型过滤。
■下面给出一个我自己写的完整的登陆程序，用PreparedStatement实现的
public class PreparedStatementTestLogin {
 public static void main(String[] args) {
  Connection conn = null;
  PreparedStatement stmt = null;
  ResultSet rs = null;
  String username = null;
  String password = null;
  BufferedReader reader = null;
  byte[] buf=null;
  int len=0;
  buf = new byte[128];
  reader = new BufferedReader(new InputStreamReader(System.in));
  
  try {
   System.out.println("输入您的用户名:");
   
   len = System.in.read(buf);//计算读入的字符个数
   username = new String(buf,0,len-System.getProperty("line.separator").length());//跨平台,因为Linux中只有＼r没有＼n
       
   System.out.println("输入您的密码:");
   len = System.in.read(buf);//计算读入的字符个数
   password = new String(buf,0,len-System.getProperty("line.separator").length());
  } catch (IOException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
  }
  if(username.length()==0||password.length()==0){
   System.out.println("姓名和密码不能为空");
   System.exit(1);
  }  
  try {
    Class.forName("com.mysql.jdbc.Driver");
    conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test user=root&password=");
    conn.setAutoCommit(false);
    String sql = "select * from user where name=  and password= ";
    stmt = conn.prepareStatement(sql,ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
                  //上面这句定义了结果集的类型
    stmt.setString(1,username);//将指定的参数(也就是1,就是第一个 )用username的值代替
    stmt.setString(2,password);
    rs=stmt.executeQuery();
      
    if(rs.next()){
    
     System.out.println("验证通过!");
     System.out.println("更改密码请按1并回车,增加用户请按2并回车");
     Scanner in = new Scanner(System.in);
     int num = in.nextInt();
     if(num==1){
      System.out.println("请输入密码：");
      Scanner in2 = new Scanner(System.in);
      String str = in2.nextLine();
      rs.updateString("password",str);//注意类型
      rs.updateRow();//一定要这句，才会往数据库里更新，另外生成语句的时候PreparedStatement要设置结果集类型。
      System.out.println("密码更改成功!");
     } 
      
     //输入新用户：
     if(num==2){ 
      String newuser=null;
      String newUserpw=null;
      try {
       System.out.println("请输入新用户名：");
       newuser = reader.readLine();
       System.out.println("请输入新用户密码：");
       newUserpw = reader.readLine();
      } catch (IOException e) {
       e.printStackTrace();
      }
      
      //将游标移到可插入位置
      rs.moveToInsertRow();
      //修改记录
      rs.updateString("name",newuser);
      rs.updateString("password",newUserpw);
     }
    }else
    {
     System.out.println("用户名或者密码有误!");
    }
    conn.commit();
 
   } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }catch (SQLException e) {
   e.printStackTrace();
   try {
    conn.rollback();
   } catch (SQLException e1) {
    e1.printStackTrace();
   }
  }
   finally{
   try {
    if(rs!=null){
    rs.close();
    rs=null;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   }
   
   try {
    if(stmt!=null){
     stmt.close();
     stmt=null;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   }
   try {
    if(conn!=null&&!conn.isClosed()){
     conn.close();
     conn=null;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  return;
 }
}
标准的写法就是这样的，注意finally中的几个关闭，这样才能将发生错误的可能减少到最低.
■结果集 ResultSet .
结果集(ResultSet)有三个属性：类型、并发性、有效性。
结果集(ResultSet)分三种类型
TYPE_FORWARD_ONLY: 游标仅仅可以向前移动
TYPE_SCROLL_INSENSITIVE: 游标可以前后移动并且可以循环移动，而且对底层数据库的变化是不敏感的，也就是说
                         从数据库中取出结果集之后，如果这时别人修改了数据库，那么结果集是不变的
TYPE_SCROLL_SENSITIVE: 和上面对应，不同之处是如果别人更改了数据库，那么结果集也会发生相应的变化。
对于可以任意移动指针的结果集(后两个类型)，可以用来移动指针的方法包括：
next和previous：
absolute和relative：参数可正可负
afterLast、beforeFirst、last和first：
结果集的并发性共有两种，CONCUR_READ_ONLY的结果集是只读而不可更新的；
而CONCUR_UPDATABLE的结果集则是可以通过update方法进行更新的。
结果集的有效性是指在调用了Connection接口的commit方法后，结果集是否自动关闭游标。
所以它只有两个可选值，即HOLD_CURSORS_OVER_COMMIT和CLOSE_CURSORS_AT_COMMIT。
前者表示调用commit方法之后，结果集不关闭；而后者则表示关闭结果集。 ]]> 2006-12-13 15:37:17 <![CDATA[ JDBC第四天 ]]> http://blog.tom.com/hoohey/article/1569.html 时间：2006-12-03 内容：深拷贝/浅拷贝、深克隆/浅克隆
 
零碎知识：
1、基本数据类型(int,char,float,double,byte,short,long,boolean)所在的内存空间位于栈中。
2、只要是通过new操作创建出来的都是对象，对象位于堆中。
3、引用是对象的地址，位于栈中。
4、通过classA instanceof classB来判断A是否为B的实例，返回的结果是boolean型。
5、所有的类都是从Object继承而来，故所有的类都有equals方法，而最初Object的equals都只是比较地址，但是那些包装类(比如Integer、
String等)SUN公司已经做了覆盖，所以他们是比较值的
6、多态：子类继承父类，父类的属性不会被覆盖,下面给出一个多态的例子:
 class Father
 {
  int x = 2;
  int method(){
   return x;
  }
 }
 public class Son extends Father
 {
  int x = 3 ;
  int method(){
  return x ;
  }
  public static void main(String[] args)
  {
  Father f = new Son();
  System.out.println(f.x);
  System.out.println(f.method());
  }
 }
结果为：2
       3
【深/浅拷贝】
先写一个Person类

public class Person{
 String name = null;
 int idcard ;
 public Person(){}
 public Person(String name,int idcard){
  this.name = name;
  this.idcard= idcard;
  
 } 
/* public boolean equals(Object obj)
 {
  boolean result = false;
  if(obj instanceof Person)
  {
   Person p = (Person) obj;
   if((p.getName()==this.getName())&&(p.getidcard()==this.getidcard()))
     result = true;
  }
  return result;
 }*/
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getidcard() {
  return idcard;
 }
 public void setidcard(int idcard) {
  this.idcard = idcard;
 }
/* public int hashCode() {
  //默认情况下是return super.hashCode();
  return new Integer(this.idcard).hashCode()+new String(this.name).hashCode();
 } */
}
}
再给出上面类的一个应用
public class Test {
 public static void main(String[] args) {
  Person p1 = new Person("Hoo", 24);
  Person p2 = new Person("Hey", 24);
  Person p3 = new Person(new String("Gavin"), 28);
  Person p4 = new Person(new String("King"), 28);
  /**
   * 下面浅拷贝，只是把p2的getName()的地址和getidcard()的地址拷贝给p1 那么它们肯定是指向相同的内容
   */
  p1.setName(p2.getName());
  p1.setidcard(p2.getidcard());
  /**
   * 下面深拷贝，把p4的getName()的值和getidcard()的值拷贝到另一个地方 然后将p3指向该地址
   */
  p3.setName(p4.getName());
  p3.setidcard(p4.getidcard());
  System.out.println(p1.getName() == p2.getName()); // true
  System.out.println(p3.getName() == p4.getName()); // true
  System.out.println(p1 == p2);
  System.out.println(p3 == p4);
  /**
   * 如果Person类覆盖了equals类，那么hashCode()也要覆盖,因为我们认为姓名和身份证号
   * 相同那么就是同一个人，这样的话hashCode()应该相同.如果不覆盖这两个对象的hashCode肯定不一样。
   * 但是hashCode()相同就不一定是同一个人,因为Name.hashCode()+Age.hashCode相等的话，不一定姓名和idcard一样
   */
  System.out.println(p1.hashCode());
  System.out.println(p2.hashCode());
 }
}
重点:**如果对象相同(equals返回true)，那么要求hashCode返回相同，因为要往hashtable里面插；
     **如果hashCode相同，不一定对象相同(即不一定equals方法返回true)；
     **那些包装类SUN公司已经覆盖了equals方法，即完成了我们的覆盖操作
     **学会覆盖equals和hashCode方法和理解什么情况下需要覆盖.
【克隆】:
某个类要实现clone方法的话，必须实现cloneable()接口(是个空接口)，标明对象可以克隆，而且要覆盖父类(即Object)的clone方法，因为默
认情况下clone方法是private的，要更改为public。
public class Person implements cloneable()
{
 ...
 public Object clone() throws CloneNotSupportedException{
 /* Person p = new Person(this.age,this.name) ;
  return p ;*/
  return super.clone(); 
 }
}
Person p = new Person(32,"john");
try
{
 Person p1 = (Person)p.clone();
 System.out.println(p1.age==p.age);  //true ;
 System.out.println(p1.name==p.name); //true ;
 System.out.println(p==p1);  //false ;
 //可见，即便是使用super.clone()方法还是实现的是浅克隆，对象的副本中的属性和主本中的属性
 //其实还是一个地址。
}
catch(CloneNotSupportedException ex)
{
 ex.printStackTrace();
}
注意：使用clone时，不能用其他类的clone方法，比如另一个类想用Person.clone()是会出错的
【集合类】
分两类:Collection和Map
List和Set都继承了Collection
List：add(int index,Object element)：如果往第三个位置插入一个元素的话，其他元素顺序
      往下移动，List是有索引的，也就是说它是有序的集合
    List 有分ArrayList和LinList,他们之间的区别是前者是一个数组list后者是链表list，数组有空间上的限制(数组溢出)而链表没有，但
是数组的读取速度要高于链表.
 ArrayList().add(pos,obj);//存储的是Obj,pos是在数组中的位置
 ArrayList().get(pos); //可以通过get来取的第pos个位置上的Obj
Set：List有顺序但不唯一,Set无序但唯一(不包含重复元素)，里面最多包含一个null值
   由于Set没有get方法(因为它无序),所以必须通过迭代器来遍历所有元素

【迭代器】 Iterator     
Iterator it = list.iterator();
while(it.hasNext)  //表示有没有下一个,有的话执行里面的
{
 Object obj = it.next();
 if(obj instanceof Person){}
 else }
  System.out.println(obj);
 }
}
所有的对象都有Iterator ]]> 2006-12-10 13:32:52 <![CDATA[ JDBC第三天 ]]> http://blog.tom.com/hoohey/article/1568.html 时间:2006-12-02 内容:SqlServer2005
 
   今天兼职袁SIR主讲SqlServer,其实我SqlServer挺熟的,毕竟用了好几个月呢,可是听了他讲才发现我只是懂点皮毛,分页是我所不知道的,最高兴的一点是,存储过程我终于知道怎么写了,原来这么简单....
来看一个存储过程先
if object_id('hoohey') is not null    //先判断是否存在
   drop proc hoohey
go

create proc hoohey(@Player varchar(20))//其中()里的是参数,注意要@
as
begin
  declare @MaxScore  float,
          @MinScore  float,
          @MaxJudge  varchar(20),
          @MinJudge  varchar(20)
select @MaxScore=Max(Score),@MinScore=min(Score) from Grade where Player=@Player
select @MaxJudge=Judge from Grade where Score=@MaxScore and Player=@Player
select @MinJudge=Judge from Grade where Score=@MinScore and Player=@Player
select (sum(Score)-@MaxScore-@MinScore)/(count(*)-2) as AverScore,@MaxScore,@MinScore,@MaxJudge,@MinJudge from Grade where Player=@Player
end

exec hoohey //执行存储过程
 
例子：自动生成身份证号(给两个参数一个地区,一个日期)：
create table Person //建表
{
 id int identity(1,1) primary key,
 CardNo varchar(18),
 Name nvarchar(10)
}
insert into values(CardNo,Name) values('422423197504124559','袁龙友')
插入袁SIR的身份证号码
select * from Person
注意：422423197504124559去掉前6位和后4位，得到的是19750412，这就是袁老师的
出生日期，存储过程要求生成一个身份证号码，前6位保持不变，而且后4位要加上1，
中间的是生日。
这个存储过程给了前6位号，中间8位号，我们只要顾及最后4位号就可以了。
if object_id('GenNewCardNo') is not null
  drop proc GenNewCardNo
go
create proc GenNewCardNo(@RegionCode varchar(6),@Birthday varchar(8))
as
begin
   declare @CardNo varchar(18)
  
   select @CardNo=@RegionCode+@Birthday+replace(str(max(Right(CardNo,4))+1,4),' ','0')
     from Person where left(CardNo,4) = @RegionCode+@Birthday
 
 insert into Person(CardNo) values(@CardNo)
end
exec GenNewCardNo '422423','19750412'
 
如果你是符合条件的第一个人的话，那么where条件还不成立呢，因为还没有满足条件的记录呢！那么如果这样的话刚才的存储过程就无法得到记录了！上面的存储过程无法处理当天第一个出生的人！
可以设置一个号码，如果真的是空的话，给它置为1。
begin
   declare @CardNo varchar(18)
   @Num int
 select @Num = max(right(CardNo,4))+1 from Person where left(CardNo,4) = @RegionCode+@Birthday
 if @Num is null //如果确实是当天第一个出生的人，那么肯定数据库中没有相应的身份证记录，那么@Num必然为空！
  set @Num=1
 
   select @CardNo=@RegionCode+@Birthday+replace(str(@Num,4),' ','0')
    
 
 insert into Person(CardNo) values(@CardNo)
 select @CardNo
end
exec GenNewCardNo '422421','19750412'
 
要知道索引重建的意义,因为如果建了索引的话,每次插入数据,索引要变动一下,时间长了,更新记录的时候会变的速度很慢,因为记录要一条条往后移,所以要重建索引.一般情况下,表不多,字段文本比较大,经常修改这样的列不该建索引..
 
 
分页:
select top n column from table //选前几条记录比如n=10就是前10条
最好用,但也有局限性(只满足只有一条主键的表):
declare @ID int
select top 10 @ID=ID from table
//取第一页的前10行，最后的第10行ID数值被赋给了@ID,但是这对主键的要求比较高，要求必须升序且不跳数。
print @ID //这时@ID=10
select top 10 * from table where ID>@ID
 
  ]]> 2006-12-06 19:55:55 <![CDATA[ JDBC第二天 ]]> http://blog.tom.com/hoohey/article/1567.html 时间:2006-12-01 内容:Statement及DataSource
同期同学袁彬(思路很清晰的一个小伙子)写的很详细,改天再细细拜读一下:
http://blog.csdn.net/ecaterina/archive/2006/12/05/1430787.aspx
 
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class IsolationDemo {
 
 public static void main(String[] args) {
  
  Connection conn = null;
  Statement stmt = null;
  ResultSet rs = null;
  
  try {
   Class.forName("oracle.jdbc.OracleDriver");
   conn = DriverManager.getConnection ("jdbc:oracle:thin:hr/hr@localhost:1521:orcl");
   DatabaseMetaData dmd = conn.getMetaData();
   if(dmd.supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE)) {
    System.out.println("Transaction Isolation Level setted!");
    conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
   }
   conn.setAutoCommit(false);
   
   stmt = conn.createStatement();
   rs = stmt.executeQuery("select salary from employees where employee_id=200");//stmt.executeQuery("select count(*) from employees");
   if(rs.next()) System.out.println(rs.getString(1));
   
   Thread.sleep(15000);//停滞15秒,然后另一个进程更新数据库
   
   rs = stmt.executeQuery("select salary from employees where employee_id=200");//stmt.executeQuery("select count(*) from employees");
   if(rs.next()) System.out.println(rs.getString(1));
   conn.commit();
   
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}
这段代码的目的是演示防止脏读和不可重复读而写的,注意蓝色代码,于是就引出:
★事务的隔离级别
（1）有几种事务隔离级别。//有5种, JDK1.5的connection中Field Summary
 TRANSACTION_NONE  //不支持事务。
 TRANSACTION_READ_COMMITTED  //阻止脏读，但不能阻止幻读和不可重复读
 TRANSACTION_READ_UNCOMMITTED
 TRANSACTION_REPEATABLE_READ  //能防止不可重复读和脏读
 TRANSACTION_SERIALIZABLE //能防止上述的三种
（2）事务隔离级别较低时可能会导致的脏读、不可重复读和幻读分别是什么含义
 脏读：一个事务读到另一个事务的中间状态,比如读到更新过程中的数据
 幻读：读的过程中有人加了记录,记录数目增加了
 不可重复读：读的过程中有人更改了记录,记录被更新过,但数目没加
（3）知道如何更改驱动程序的事务隔离级别。
 
1、事务边界
（1）默认情况下，JDBC每执行一条DML语句就提交一次，即一句话就是一个事务。
（2）如果需更改事务边界，需调用Connection.setAutoCommit(false);来取消自动提交。然后在事务结束的地方调用Connection.commit()提交事务，在异常代码块加rollback()回滚事务。
2、保存点
（1）创建保存点，Connection.setSavepoint()生成保存
（2）回滚到保存点，Connection.rollback(Savepoint);
e.g:
        SavePoint sp = conn.setSavePoint("first");
        ...
        conn.rollback(sp);
  ]]> 2006-12-06 19:24:21