import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ObjectClone {

 public static void main(String[] args) throws Exception,
   IllegalAccessException, Exception {

  Person jack = new Person("jack", 24, "hangzhou");
  Person brown = new Person("brown", 54, "hangzhou");
  jack.setFather(brown);
  brown.setArray(new String[]{"lin","feng"});
  String[] arr = { "lin", "fu" };
  jack.setArray(arr);
  Person lily = new Person();
  copyProperties(lily,jack);
   jack.getFather().setAddress("shanghai");
  jack.setAddress("test");

  System.out.println("jack" + jack.toString());
  System.out.println("lily" + lily.toString());

  System.out.println("jack.father:" + jack.getFather());
  System.out.println("lily.father:" + lily.getFather());

 }

 public static  void copyProperties(Object destObj,Object srcObj) throws Exception {
  // 取得拷贝对象的所有域
  Field[] fieldsBase = srcObj.getClass().getDeclaredFields();
  Field.setAccessible(fieldsBase, true);
  // 取得目标对象的所有域
  Field[] fieldsObj = destObj.getClass().getDeclaredFields();
  Field.setAccessible(fieldsObj, true);
  for (int i = 0; i < fieldsObj.length; i++) {
   // 取得域名称
   Field fieldObj = fieldsObj[i];
   for (int j = 0; j < fieldsBase.length; j++) {
    Field fieldBase = fieldsBase[j];
    // 比较两域名称是否一致
    if (fieldObj.getName().equals(fieldBase.getName())) {
     // 取得域名称并将第一个字母大小
     String fieldName = fieldObj.getName();
     String firstChar = fieldName.substring(0, 1).toUpperCase();
     fieldName = firstChar + fieldName.substring(1);
     // 取得目标对象中的set方法
     Method methodObj = destObj.getClass().getMethod(
       "set" + fieldName,
       new Class[] { fieldObj.getType() });
     // 取得参照对象中的get方法
     Method methodGet = srcObj.getClass().getMethod(
       "get" + fieldName, null);
     // 执行参照对象的get方法并取得返回值
     Object resultObj = methodGet.invoke(srcObj, null);
     // 执行目标对象的set方法并进行设值
     methodObj.invoke(destObj, new Object[] { resultObj });
     break;
    }
   }
  }
 }

 // 深层克隆，主要利用一个递归调用
 public static Object cloneExt(Object obj) throws Exception {
  // getDeclaredFields得到object内定义的所有field
  Field[] fields = obj.getClass().getDeclaredFields();
  // 利用newInstance方法，生成一个空的Object
  Object newObj = obj.getClass().newInstance();
  for (int i = 0, j = fields.length; i < j; i++) {
   String propertyName = fields[i].getName();
   // field的值
   Object propertyValue = getProperty(obj, propertyName);
   // field的类型
   String propertyType = fields[i].getType().getName();
   if (propertyValue != null) {
    // 如果field不是8种基本类型，或者String，则直接赋值
    if (propertyType.endsWith("String")
      || "char".equals(propertyType)
      || "int".equals(propertyType)
      || "boolean".equals(propertyType)
      || "byte".equals(propertyType)
      || "short".equals(propertyType)
      || "double".equals(propertyType)
      || "long".equals(propertyType)
      || "float".equals(propertyType)
      || "void".equals(propertyType)) {
     setProperty(newObj, propertyName, propertyValue);
    } else {
     // 如果field类型是其他Object，则递归克隆一下
     Object newPropObj = cloneExt(propertyValue);
     setProperty(newObj, propertyName, newPropObj);
    }
   }
  }
  return newObj;
 }

 // 浅层克隆
 public static Object clone(Object obj) throws Exception {
  Field[] fields = obj.getClass().getDeclaredFields();
  Object newObj = obj.getClass().newInstance();
  for (int i = 0, j = fields.length; i < j; i++) {
   String propertyName = fields[i].getName();
   Object propertyValue = getProperty(obj, propertyName);
   setProperty(newObj, propertyName, propertyValue);
  }
  return newObj;
 }

 // 反射调用setter方法，进行赋值
 private static Object setProperty(Object bean, String propertyName,
   Object value) {
  Class clazz = bean.getClass();
  try {
   Field field = clazz.getDeclaredField(propertyName);
   Method method = clazz.getDeclaredMethod(getSetterName(field
     .getName()), new Class[] { field.getType() });
   return method.invoke(bean, new Object[] { value });
  } catch (Exception e) {
  }
  return null;
 }

 // 反射调用getter方法，得到field的值
 private static Object getProperty(Object bean, String propertyName) {
  Class clazz = bean.getClass();
  try {
   Field field = clazz.getDeclaredField(propertyName);
   Method method = clazz.getDeclaredMethod(getGetterName(field
     .getName()), new Class[] {});
   return method.invoke(bean, new Object[] {});
  } catch (Exception e) {
  }
  return null;
 }

 // 根据field名，得到getter方法名
 private static String getGetterName(String propertyName) {
  String method = "get" + propertyName.substring(0, 1).toUpperCase()
    + propertyName.substring(1);
  return method;
 }

 // 根据field名，得到setter方法名
 private static String getSetterName(String propertyName) {
  String method = "set" + propertyName.substring(0, 1).toUpperCase()
    + propertyName.substring(1);
  return method;
 }
}

class Person {

 private String name;

 private int age;

 private String address;

 // 用于测试深层克隆
 private Person father;

 private String array[] = null;

 public Person() {

 }

 public Person(String name, int age, String address) {
  this.name = name;
  this.address = address;
  this.age = age;
 }

 public Person(String name, int age, String address, Person father) {
  this.name = name;
  this.address = address;
  this.age = age;
  this.father = father;
 }

 // 所有的getter方法和setter方法要求都是public，且具有一定的命名规则
 public String getAddress() {
  return address;
 }

 public void setAddress(String address) {
  this.address = address;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public Person getFather() {
  return father;
 }

 public void setFather(Person father) {
  this.father = father;
 }

 public String toString() {
  String sum = "";
  for (String s : array) {
   sum += " " + s;
  }
  return "{Name=" + name + ",Age=" + age + ",Address=" + address + sum
    + "}";
 }

 public String[] getArray() {
  return array;
 }

 public void setArray(String[] array) {
  this.array = array;
 }
}

import java.util.Random;

public class Consumer implements Runnable {
    private Drop drop;

    public Consumer(Drop drop) {
        this.drop = drop;
    }

    public void run() {
        Random random = new Random();
        for (String message = drop.take(); ! message.equals("DONE");
                message = drop.take()) {
            System.out.format("MESSAGE RECEIVED: %s%n", message);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
    }
}

import java.util.Random;

public class Producer implements Runnable {
    private Drop drop;

    public Producer(Drop drop) {
        this.drop = drop;
    }

    public void run() {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };
        Random random = new Random();

        for (int i = 0; i < importantInfo.length; i++) {
            drop.put(importantInfo[i]);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
        drop.put("DONE");
    }
}

public class Drop {
    //Message sent from producer to consumer.
    private String message;
    //True if consumer should wait for producer to send message, false
    //if producer should wait for consumer to retrieve message.
    private boolean empty = true;

    public synchronized String take() {
        //Wait until message is available.
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        //Toggle status.
        empty = true;
        //Notify producer that status has changed.
        notifyAll();
        return message;
    }

    public synchronized void put(String message) {
        //Wait until message has been retrieved.
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        //Toggle status.
        empty = false;
        //Store message.
        this.message = message;
        //Notify consumer that status has changed.
        notifyAll();
    }
}      

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import com.itextpdf.text.Document;
import com.itextpdf.text.pdf.PdfReader;
public class TestPdf {
 private static ArrayList<String> pdffiles = new ArrayList<String>();

 /**
  * 递归得到特定目录下的所有文件
  */
 public static void getAllPdfFile(String basedir) {
  File dir = new File(basedir);
  File[] files = dir.listFiles(new PdfFileFilter());
  if (files == null)
   return;
  for (int i = 0; i < files.length; i++) {
   if (files[i].isDirectory()) {
    getAllPdfFile(files[i].getAbsolutePath());
   } else {
    pdffiles.add(files[i].getAbsolutePath());
   }
  }
 }
 /**
  * 循环检测
  */
 private static void CheckPdfFiles(ArrayList<String> files) {
  for (String file : files) {
   boolean flag = false;
   flag = check(file);
   if (!flag) {
    System.out.println(file + "文件损坏");
   }
  }
 }

 /**
  * 利用itext打开pdf文档
  */
 private static boolean check(String file) {
  boolean flag1 = false;
  int n = 0;
  try {
   Document document = new Document(new PdfReader(file).getPageSize(1));
   document.open();
   PdfReader reader = new PdfReader(file);
   n = reader.getNumberOfPages();
   if (n != 0)
    flag1 = true;
   document.close();
  } catch (IOException e) {
   System.out.println(e.getMessage());
  }
  return flag1;

 }

 public static void main(String[] args) {
  getAllPdfFile("C:\\CO_uat\\");
  if (pdffiles.size() > 0)
   CheckPdfFiles(pdffiles);
  System.out.println("No break down file");
 }
}
/*
 * pdf文件过滤器
 */
class PdfFileFilter implements FileFilter {
 public boolean accept(File file) {
  if (file.isFile()) {
   String filename = file.getName().toLowerCase();
   if (filename.endsWith(".pdf") == true) {
    return true;
   } else {
    return false;
   }
  } else {
   return true;
  }
 }

}

public class FileTools {
 private static final String SPECIAL_FILE_STYLE_PICTURECACHE = "Thumbs.db";
 public static final Logger logger = LogManager.getLogger(FileTools.class);
 
 public FileTools()
 {
  
 }
 /*
  * @discription:Delete a folder
  * @param:dirPath String
  * @return boolean
  */
 public static boolean deleteDirectory(String dirPath,boolean deteDirRoot)
 {
  File parentFile = new File(dirPath);
  File[] chirenFile = null;
  if(parentFile.exists() && parentFile.isDirectory())
  {
    chirenFile = parentFile.listFiles();
    for (int i = 0; i < chirenFile.length; i++) {
     if(!chirenFile[i].isDirectory())
     {
      chirenFile[i].delete();
     }
     else
     {
      deleteDirectory(chirenFile[i].getAbsolutePath(),true);     
      chirenFile[i].delete();
     }
    }
    if(deteDirRoot)
    {
     parentFile.delete();
    }
    
    return true;  
  }
  else
  {
   FileTools.logger.error("The Floder Is Not Exist!");
   return false;
  }
 }
 
 /*
  * @discription:Copy Folder
  * @param:sourceFilePath String,targetFilePath String
  * @return boolean
  */
 public static boolean copyDirectory(String sourceFilePath,String targetFilePath) throws IOException
 {
  File sourceFile = new File(sourceFilePath);
  File targetFile = new File(targetFilePath);
  
  if(!targetFile.exists())
  {
   targetFile.mkdir();
  }
  
  File[] sourceChirenFile = null;
  FileInputStream fileInputStream = null;
  FileOutputStream fileOutputStream = null;
  FileTools.logger.debug("Copy "+sourceFile.getName()+" Floder Start......");
  if(sourceFile.exists() && sourceFile.isDirectory())
  {
   sourceChirenFile = sourceFile.listFiles();
   for (int i = 0; i < sourceChirenFile.length; i++) {
    File tempFile = null;
    
    if(!sourceFilePath.endsWith(File.separator))
    {
     tempFile = new File(targetFilePath+File.separator+sourceChirenFile[i].getName());
    }
    else
    {
     tempFile = new File(targetFilePath+sourceChirenFile[i].getName());
    }
    if(!FileTools.SPECIAL_FILE_STYLE_PICTURECACHE.equalsIgnoreCase(sourceChirenFile[i].getName()))
    {
     if(!sourceChirenFile[i].isDirectory())
     {
      fileInputStream = new FileInputStream(sourceChirenFile[i]);
      fileOutputStream = new FileOutputStream(tempFile);
      byte[] b = new byte[1024];
      FileTools.logger.debug("Copy "+sourceChirenFile[i].getName()+" File Start......");
         while(fileInputStream.read(b)!=-1)
         {
          fileOutputStream.write(b);
         }
         FileTools.logger.debug("Copy "+sourceChirenFile[i].getName()+"  File End!");
         fileInputStream.close();
         fileOutputStream.close(); 
     }
     else
     {
      copyDirectory(sourceFilePath+File.separator+sourceChirenFile[i].getName(),
              targetFilePath+File.separator+sourceChirenFile[i].getName());
     }
    }
    
   }
   FileTools.logger.debug("Copy "+sourceFile.getName()+" Floder End!");
   return true;
  }
  else
  {
   FileTools.logger.error("The Floder Is Not Exist!");
   return false;
  }
 }
}
Junit测试类

import java.io.IOException;

import org.coolyongzi.FileTools;

import junit.framework.TestCase;

public class FileToolsTest extends TestCase {

 protected void setUp() throws Exception {
  super.setUp();
 }

 protected void tearDown() throws Exception {
  super.tearDown();
 }

 public void testDeleteDirectory()
 {
  FileTools.deleteDirectory("F:/复件 图片",false);
 }
 
 public void testCopyDirectory()
 {
  try {
   FileTools.copyDirectory("F:/Game","F:/Game1");
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

/**
 * Title:        Java Bean 工具
 * Description:
 * Copyright:    Copyright (c) 2001
 * Company:      JAVA世纪网 http://www.java2000.net
 * @author 赵学庆
 * @version 1.0
 */
import java.util.*;
import java.util.regex.Pattern;

public class StrTools {
 /**
  * 分割字符串
  *
  * @param str
  *            String 原始字符串
  * @param splitsign
  *            String 分隔符
  * @return String[] 分割后的字符串数组
  */
 @SuppressWarnings("unchecked")
 public static String[] split(String str, String splitsign) {
  int index;
  if (str == null || splitsign == null)
   return null;
  ArrayList al = new ArrayList();
  while ((index = str.indexOf(splitsign)) != -1) {
   al.add(str.substring(0, index));
   str = str.substring(index + splitsign.length());
   //System.out.println("str is : " +str);
  }
  al.add(str);
  return (String[]) al.toArray(new String[0]);
 }

 /**
  * 替换字符串
  *
  * @param from
  *            String 原始字符串
  * @param to
  *            String 目标字符串
  * @param source
  *            String 母字符串
  * @return String 替换后的字符串
  */
 public static String replace(String from, String to, String source) {
  if (source == null || from == null || to == null)
   return null;
  StringBuffer bf = new StringBuffer("");
  int index = -1;
  while ((index = source.indexOf(from)) != -1) {
   bf.append(source.substring(0, index) + to);
   source = source.substring(index + from.length());
   index = source.indexOf(from);
  }
  bf.append(source);
  return bf.toString();
 }

 /**
  * 替换字符串，能能够在HTML页面上直接显示(替换双引号和小于号)
  *
  * @param str
  *            String 原始字符串
  * @return String 替换后的字符串
  */
 public static String htmlencode(String str) {
  if (str == null) {
   return null;
  }

  return replace("\"", "&quot;", replace("<", "&lt;", str));
 }

 /**
  * 替换字符串，将被编码的转换成原始码（替换成双引号和小于号）
  *
  * @param str
  *            String
  * @return String
  */
 public static String htmldecode(String str) {
  if (str == null) {
   return null;
  }

  return replace("&quot;", "\"", replace("&lt;", "<", str));
 }

 private static final String _BR = "<br/>";

 /**
  * 在页面上直接显示文本内容，替换小于号，空格，回车，TAB
  *
  * @param str
  *            String 原始字符串
  * @return String 替换后的字符串
  */
 public static String htmlshow(String str) {
  if (str == null) {
   return null;
  }

  str = replace("<", "&lt;", str);
  str = replace(" ", "&nbsp;", str);
  str = replace("\r\n", _BR, str);
  str = replace("\n", _BR, str);
  str = replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;", str);
  return str;
 }

 /**
  * 返回指定字节长度的字符串
  *
  * @param str
  *            String 字符串
  * @param length
  *            int 指定长度
  * @return String 返回的字符串
  */
 public static String toLength(String str, int length) {
  if (str == null) {
   return null;
  }
  if (length <= 0) {
   return "";
  }
  try {
   if (str.getBytes("GBK").length <= length) {
    return str;
   }
  } catch (Exception ex) {
  }
  StringBuffer buff = new StringBuffer();

  int index = 0;
  char c;
  length -= 3;
  while (length > 0) {
   c = str.charAt(index);
   if (c < 128) {
    length--;
   } else {
    length--;
    length--;
   }
   buff.append(c);
   index++;
  }
  buff.append("...");
  return buff.toString();
 }

 /**
  * 判断是否为整数
  *
  * @param str
  *            传入的字符串
  * @return 是整数返回true,否则返回false
  */
 public static boolean isInteger(String str) {
  Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
  return pattern.matcher(str).matches();
 }

 /**
  * 判断是否为浮点数，包括double和float
  *
  * @param str
  *            传入的字符串
  * @return 是浮点数返回true,否则返回false
  */
 public static boolean isDouble(String str) {
  Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
  return pattern.matcher(str).matches();
 }

 /**
  * 判断输入的字符串是否符合Email样式.
  *
  * @param str
  *            传入的字符串
  * @return 是Email样式返回true,否则返回false
  */
 public static boolean isEmail(String str) {
  Pattern pattern = Pattern
    .compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
  return pattern.matcher(str).matches();
 }

 /**
  * 判断输入的字符串是否为纯汉字
  *
  * @param str
  *            传入的字符窜
  * @return 如果是纯汉字返回true,否则返回false
  */
 public static boolean isChinese(String str) {
  Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
  return pattern.matcher(str).matches();
 }

 /**
  * 是否为空白,包括null和""
  *
  * @param str
  * @return
  */
 public static boolean isBlank(String str) {
  return str == null || str.trim().length() == 0;
 }

 /**
  * 判断是否为质数
  *
  * @param x
  * @return
  */
 public static boolean isPrime(int x) {
  if (x <= 7) {
   if (x == 2 || x == 3 || x == 5 || x == 7)
    return true;
  }
  int c = 7;
  if (x % 2 == 0)
   return false;
  if (x % 3 == 0)
   return false;
  if (x % 5 == 0)
   return false;
  int end = (int) Math.sqrt(x);
  while (c <= end) {
   if (x % c == 0) {
    return false;
   }
   c += 4;
   if (x % c == 0) {
    return false;
   }
   c += 2;
   if (x % c == 0) {
    return false;
   }
   c += 4;
   if (x % c == 0) {
    return false;
   }
   c += 2;
   if (x % c == 0) {
    return false;
   }
   c += 4;
   if (x % c == 0) {
    return false;
   }
   c += 6;
   if (x % c == 0) {
    return false;
   }
   c += 2;
   if (x % c == 0) {
    return false;
   }
   c += 6;
  }
  return true;
 }

 public static void main(String[] args) {
  String[] numbers = { "12345", "-12345", "123.45", "-123.45", ".12345",
    "-.12345", "a12345", "12345a", "123.a45" };
  for (String str : numbers) {
   System.out
     .println(str + "=" + isInteger(str) + " " + isDouble(str));
  }

  String[] emails = { "1@2.com", "1.2@3.com", "1@3.4.5.com" };
  for (String str : emails) {
   System.out.println(str + "=" + isEmail(str));
  }
  String[] chineses = { "中国", "1中国", "中国1", "1中国2", "中1国" };
  for (String str : chineses) {
   System.out.println(str + "=" + isChinese(str));
  }
   String str = "lin@san@fu@2009";
   String[] strArray =split(str,"@");
   for(String s: strArray)
   System.out.println(s);
 }
}
-------------------------------------------------------------------------------------------------
/* * Db.java
Created on 2007年8月20日, 上午 8:37
*/
import java.io.*;
import java.sql.*;
import java.util.Properties;
public class Db {
    private String driver;
    private String url;
    private String user;
    private String password;
    private Connection conn;
    private Statement stm;
    private ResultSet rs;
    public Db(){
        this("DBConf.properties");
    }
    public Db(String conf) {
        loadProperties(conf);
        setConn();
    }
    public Connection getConn(){
        return this.conn;
    }
  //handle the properties file to get the informations for connection
    private void loadProperties(String conf){
        Properties props = new Properties();
        try {
            props.load(new FileInputStream(conf));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.driver = props.getProperty("driver");
        this.url = props.getProperty("url");
        this.user = props.getProperty("user");
        this.password = props.getProperty("password");
    }
    //implement the Connection
    private void setConn(){
        try {
            Class.forName(driver);
            this.conn = DriverManager.getConnection(url,user,password);
        } catch(ClassNotFoundException classnotfoundexception) {
              classnotfoundexception.printStackTrace();
            System.err.println("db: " + classnotfoundexception.getMessage());
        } catch(SQLException sqlexception) {
            System.err.println("db.getconn(): " + sqlexception.getMessage());
        }
    }
       public void doInsert(String sql) {
        try {
            Statement statement = conn.createStatement();
            int i = stm.executeUpdate(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeInset:" + sqlexception.getMessage());
        }
    }
    public void doDelete(String sql) {
        try {
            stm = conn.createStatement();
            int i = stm.executeUpdate(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeDelete:" + sqlexception.getMessage());
        }
    }
    public void doUpdate(String sql) {
        try {
            stm = conn.createStatement();
            int i = stm.executeUpdate(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeUpdate:" + sqlexception.getMessage());
        }
    }
   
    public ResultSet doSelect(String sql) {
        try {
            stm = conn.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,java.sql.ResultSet.CONCUR_READ_ONLY);
            rs = stm.executeQuery(sql);
        } catch(SQLException sqlexception) {
            System.err.println("db.executeQuery: " + sqlexception.getMessage());
        }
        return rs;
    }
    public static void main(String[] args){
        try{
            Db db = new Db();
            Connection conn = db.getConn();
            if(conn != null && !conn.isClosed()) {
                System.out.println("連結成功");
                ResultSet rs = db.doSelect("select * from content");
                while(rs.next()){
                    System.out.println(rs.getString(1)+":"+rs.getString(2)+":"+rs.getString(3));
                  }
                rs.close();
                conn.close();
            }
        }catch(SQLException e) {
            e.printStackTrace();
        }
    } 
}

/**
 * JAVA里面如何使用一个线程死亡或结束.
 * @author 赵学庆，Java世纪网(java2000.net)
 *
 */
public class T {
  public static void main(String[] args) {
    // 启动线程
    MyThread thread = new MyThread();
    new Thread(thread).start();

    // 你的其它的工作，此时线程在运行中

    // 你不想让线程干活了，停掉它
    // 注意，这只是一个标志，具体线程何时停，并不能精确控制
    thread.allDone = true;

  }

}

class MyThread implements Runnable {
  boolean volatile allDone = false;

  public void run() {
    // 每次循环都检测标志
    // 如果设置停止标志时已经在循环里
    // 则最长需要等待一个循环的时间才能终止
    while (!allDone) {
      // 循环里的工作
    }
  }
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/phphot/archive/2008/10/30/3187042.aspx

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;

import javax.net.ssl.SSLHandshakeException;

/**
 * @author lin
 *
 */
public class TestURL {

 /**
  * @param args
  */
 public static void main(String[] args)   {
  String result = "";
  try {
   java.net.URL url = new java.net.URL("http://mail.163.com");
   HttpURLConnection httpConn = (HttpURLConnection) url
     .openConnection();
   httpConn.setDoOutput(true);
   httpConn.setDoInput(true);
   httpConn.setRequestMethod("POST");
   PrintWriter out = new PrintWriter(httpConn.getOutputStream());
   out.println("Email=test@gmail.com" +"password=123456");
   out.flush();
   out.close();
   BufferedReader in = new BufferedReader(new InputStreamReader(
     httpConn.getInputStream(), "UTF-8"));
   String line;
   while ((line = in.readLine()) != null) {
    result += line + "\n";
   }
   System.out.println("result: " + result);
   in.close();
    }catch(SSLHandshakeException se){
   System.out.println("error is open");
  }
  catch (Exception e) {
   System.out.println("sucess " + e);
  }

 }
}

1. 得到某个对象的属性

1 public Object getProperty(Object owner, String fieldName) throws Exception {
2     Class ownerClass = owner.getClass();
3
4     Field field = ownerClass.getField(fieldName);
5
6     Object property = field.get(owner);
7
8     return property;
9 }
Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性

 1 public Object getStaticProperty(String className, String fieldName)
 2             throws Exception {
 3     Class ownerClass = Class.forName(className);
 4
 5     Field field = ownerClass.getField(fieldName);
 6
 7     Object property = field.get(ownerClass);
 8
 9     return property;
10 }

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法

 1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
 2
 3     Class ownerClass = owner.getClass();
 4
 5     Class[] argsClass = new Class[args.length];
 6
 7     for (int i = 0, j = args.length; i < j; i++) {
 8         argsClass[i] = args[i].getClass();
 9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

5～9行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法

 1 public Object invokeStaticMethod(String className, String methodName,
 2             Object[] args) throws Exception {
 3     Class ownerClass = Class.forName(className);
 4
 5     Class[] argsClass = new Class[args.length];
 6
 7     for (int i = 0, j = args.length; i < j; i++) {
 8         argsClass[i] = args[i].getClass();
 9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(null, args);
14 }

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建实例
 1
 2 public Object newInstance(String className, Object[] args) throws Exception {
 3     Class newoneClass = Class.forName(className);
 4
 5     Class[] argsClass = new Class[args.length];
 6
 7     for (int i = 0, j = args.length; i < j; i++) {
 8         argsClass[i] = args[i].getClass();
 9     }
10
11     Constructor cons = newoneClass.getConstructor(argsClass);
12
13     return cons.newInstance(args);
14
15 }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第5～第9行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例

1 public boolean isInstance(Object obj, Class cls) {
2     return cls.isInstance(obj);
3 }

7. 得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2     return Array.get(array,index);
3 }

附完整源码：

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * Java Reflection Cookbook
 *
 * @author Michael Lee
 * @since 2006-8-23
 * @version 0.1a
 */

public class Reflection {
    /**
     * 得到某个对象的公共属性
     *
     * @param owner, fieldName
     * @return 该属性对象
     * @throws Exception
     *
     */
    public Object getProperty(Object owner, String fieldName) throws Exception {
        Class ownerClass = owner.getClass();

        Field field = ownerClass.getField(fieldName);

        Object property = field.get(owner);

        return property;
    }

    /**
     * 得到某类的静态公共属性
     *
     * @param className   类名
     * @param fieldName   属性名
     * @return 该属性对象
     * @throws Exception
     */
    public Object getStaticProperty(String className, String fieldName)
            throws Exception {
        Class ownerClass = Class.forName(className);

        Field field = ownerClass.getField(fieldName);

        Object property = field.get(ownerClass);

        return property;
    }

    /**
     * 执行某对象方法
     *
     * @param owner
     *            对象
     * @param methodName
     *            方法名
     * @param args
     *            参数
     * @return 方法返回值
     * @throws Exception
     */
    public Object invokeMethod(Object owner, String methodName, Object[] args)
            throws Exception {

        Class ownerClass = owner.getClass();

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Method method = ownerClass.getMethod(methodName, argsClass);

        return method.invoke(owner, args);
    }

      /**
     * 执行某类的静态方法
     *
     * @param className
     *            类名
     * @param methodName
     *            方法名
     * @param args
     *            参数数组
     * @return 执行方法返回的结果
     * @throws Exception
     */
    public Object invokeStaticMethod(String className, String methodName,
            Object[] args) throws Exception {
        Class ownerClass = Class.forName(className);

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Method method = ownerClass.getMethod(methodName, argsClass);

        return method.invoke(null, args);
    }

    /**
     * 新建实例
     *
     * @param className
     *            类名
     * @param args
     *            构造函数的参数
     * @return 新建的实例
     * @throws Exception
     */
    public Object newInstance(String className, Object[] args) throws Exception {
        Class newoneClass = Class.forName(className);

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Constructor cons = newoneClass.getConstructor(argsClass);

        return cons.newInstance(args);

    }

   
    /**
     * 是不是某个类的实例
     * @param obj 实例
     * @param cls 类
     * @return 如果 obj 是此类的实例，则返回 true
     */
    public boolean isInstance(Object obj, Class cls) {
        return cls.isInstance(obj);
    }
   
    /**
     * 得到数组中的某个元素
     * @param array 数组
     * @param index 索引
     * @return 返回指定数组对象中索引组件的值
     */
    public Object getByArray(Object array, int index) {
        return Array.get(array,index);
    }
}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/nomads/archive/2006/09/05/1178867.aspx

但是实际应用中，可能会碰到这样两类的问题：

1.写UnitTest的时候，需要脱离容器，手动读取xml文件加载bean。

2.在一个Web容器中，可能某个脱离了spring管理（也就是一个非bean）的类，需要感知并读取某个spring容易的bean。

下面转了2篇文章，分别是对应上面2个问题的解决方案

http://hi.baidu.com/%C9%CF%B5%DB%D2%B2%B7%B8%C0%A7/blog/item/f934474a104c3e2008f7ef66.html

Spring中读取bean配置文件的几种方式    

BeanFactory允许InputStream作为构造函数的参数，也可以org.springframework.core.io.Resource接口。下面这个例子是用ClassPathResource作为参数：
Resource resource = new ClassPathResource("bean.xml");
BeanFactory factory = new XmlBeanFactory(resource);
ActionBean action = (ActionBean) factory.getBean("actionBean");

如果同一个Bean在配置文件有多个bean的定义，则用下面的方法取得所有的对象：
Resource resource = new ClassPathResource("bean.xml");
ListableBeanFactory factory = new XmlBeanFactory(resource);
      
Map helloBeans = factory.getBeansOfType(ActionBean.class, false, false);

    一个应用程序中往往有很多的Bean要放在配置文件，如果所有的Bean都放在一个文件中，维护起来就相当的麻烦，这时我们可以按照模块把每个模块用到Bean放到不同的配置文件，Spring提供了相应的方法：
BeanDefinitionRegistry reg = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(reg);
  
// 載入bean定義檔  
reader.loadBeanDefinitions(new ClassPathResource("bean1.xml"));
reader.loadBeanDefinitions(new ClassPathResource("bean2.xml"));
....

// 取得Bean
BeanFactory bf = (BeanFactory) reg;
Object o = bf.getBean("actionBean");

===================================================================

读取配置文件的几种方法
在读spring in aciton 时，他用的BeanFactory factory = new XmlBeanFactory(new FileInputStream("hello.xml"));
可是现在的用的1.2.6版本的构造器(XmlBeanFactory)只能接收Resource接口了，所以调不出来是正常的事情，假设现在有一个文件hello.xml
读取方法

1:ApplicationContext cx=new FileSystemXmlApplicationContext("hello.xml");//指定的路径去找文件
2:ApplicationContext factory = new ClassPathXmlApplicationContext("hello.xml");//还会在classpath去找
3:Resource fa = new FileSystemResource("hello.xml");
BeanFactory factory=new XmlBeanFactory(fa);
4:这个要设制classpath了，麻烦
　 Resource res = new ClassPathResource("com/springinaction/chapter01/hello/hello.xml");
　 BeanFactory factory=new XmlBeanFactory(res);
好了，用了上面那种方法都可以调用getBean("your bean name")了，
eg: BeanFactory factory=new XmlBeanFactory(fa);
      hello he=(hello)factory.getBean("hello");
              he.getHello();

================================================================================

贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰贰

http://babycountry.spaces.live.com/blog/cns!18767b1e2eb6d0e1!236.entry

spring 读取注册bean的一些方法(转)
       我现在在做的东西,主要用到了框架是struts2+hibernate+spring开发一个上传,下载,播放视频,听歌的东西,在做到获得到注册bean的时候,我想通过在web.xml配置context-param中获得,但老也不成功,后来在网站上看到别人写的,共同分享:
          通过几个项目的实践总结一下几种获得spring里注册Bean的方法：
一：方法一（多在struts框架中）继承BaseDispatchAction
1234567891011121314151617181920212223242526272829303132333435363738394041 package com.mas.wawacommunity.wap.web.action;
 
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionServlet;
import org.apache.struts.actions.DispatchAction;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
 
import com.mas.wawacommunity.wap.service.UserManager;
 
public class BaseDispatchAction extends DispatchAction {
    /**
    * web应用上下文环境变量
    */
    protected WebApplicationContext ctx;
 
    protected UserManager userMgr;
 
    /**
    * 获得注册Bean    
    * @param beanName String 注册Bean的名称
    * @return
    */
    protected final Object getBean(String beanName) {
        return ctx.getBean(beanName);
    }
 
    protected ActionForward unspecified(ActionMapping mapping, ActionForm form,
              javax.servlet.http.HttpServletRequest request,
              javax.servlet.http.HttpServletResponse response) {    
        return mapping.findForward("index");
    }
 
    public void setServlet(ActionServlet servlet) {
        this.servlet = servlet;
        this.ctx = WebApplicationContextUtils.getWebApplicationContext(servlet.getServletContext());
        this.userMgr = (UserManager) getBean("userManager");
    }        
}
 

action调用：
123456789101112131415161718192021222324252627282930313233343536373839 package com.mas.wawacommunity.wap.web.action;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionServlet;
 
import com.mas.wawacommunity.wap.model.News;
import com.mas.wawacommunity.wap.service.NewsManager;
 
public class NewsAction extends BaseDispatchAction {
  NewsManager newsManager;      
   
    public void setServlet(ActionServlet servlet) {
        super.setServlet(servlet);
        newsManager = (NewsManager) this.getBean("newsManager");        
  }
   
    /**
    * 得到新闻列表
    * @param mapping
    * @param form
    * @param request
    * @param resp
    * @return
    */
    public ActionForward getNewsList(ActionMapping mapping, ActionForm form,
        HttpServletRequest request, HttpServletResponse resp) {
        int category = Text.parseInt(request, "category", 0);
        int pageNo = Text.parseInt(request, "pageNo", 1);
        int pageSize = Text.parseInt(request, "pageSize", 9);
        PageRoll pageRoll = newsManager.getAllNews(category, pageNo, pageSize);              
        request.setAttribute("pageRoll", pageRoll);
        return mapping.findForward("news.list");
    }
}
 

二：方法二实现BeanFactoryAware
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253 package com.anymusic.oa.commons.service;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
 
/**
* Created by IntelliJ IDEA.
* User: Weany
* Date: 2006-4-2
* Time: 2:46:51
* To change this template use File | Settings | File Templates.
*/
public class ServiceLocator implements BeanFactoryAware {
    private static BeanFactory beanFactory = null;
 
    private static ServiceLocator servlocator = null;
 
    public void setBeanFactory(BeanFactory factory) throws BeansException {
        this.beanFactory = factory;
    }
 
    public BeanFactory getBeanFactory() {
        return beanFactory;
    }
 
    /**
    * 创建读取Bean服务类实例(从spring.xml中加载)
    * <bean id="serviceLocator" class="com.am.oa.commons.service.ServiceLocator" singleton="true" />
    */
    public static ServiceLocator getInstance() {
        if (servlocator == null)
              servlocator = (ServiceLocator) beanFactory.getBean("serviceLocator");
        return servlocator;
    }
 
    /**
    * 根据提供的bean名称得到相应的服务类    
    * @param servName bean名称    
    */
    public static Object getService(String servName) {
        return beanFactory.getBean(servName);
    }
 
    /**
    * 根据提供的bean名称得到对应于指定类型的服务类
    * @param servName bean名称
    * @param clazz 返回的bean类型,若类型不匹配,将抛出异常
    */
    public static Object getService(String servName, Class clazz) {
        return beanFactory.getBean(servName, clazz);
    }
}
 

action调用:
1234567891011121314151617181920212223242526272829303132333435363738 package com.anymusic.oa.webwork;
 
import java.util.List;
import java.util.Map;
 
import javax.servlet.http.HttpServletRequest;
 
import com.anymusic.oa.commons.service.ServiceLocator;
import com.anymusic.oa.hibernate.pojo.Role;
import com.anymusic.oa.hibernate.pojo.Users;
import com.anymusic.oa.spring.IUserService;
import com.opensymphony.webwork.ServletActionContext;
import com.opensymphony.xwork.Action;
import com.opensymphony.xwork.ActionContext;
import com.opensymphony.xwork.ModelDriven;
 
public class UserAction extends BaseAction implements Action,ModelDriven{
   
    private Users user = new Users();
    protected ServiceLocator service = ServiceLocator.getInstance();
    UserService userService = (UserService)service.getService("userService");
 
    public String execute() throws Exception {        
        return SUCCESS;
    }
 
  public Object getModel() {
        return user;
    }    
   
    public String getAllUser(){
        HttpServletRequest request = ServletActionContext.getRequest();        
        List ls=userService.LoadAllObject( Users.class );
        request.setAttribute("user",ls);    
        this.setUrl("/yonghu.jsp");
        return SUCCESS;
    }
}
 

三：方法三实现ApplicationContextAware

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687 package com.easou.framework.common.util;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
 
public class SpringContextUtil implements ApplicationContextAware {
  private static ApplicationContext applicationContext;     //Spring应用上下文环境
 
  /**
  * 实现ApplicationContextAware接口的回调方法，设置上下文环境  
  * @param applicationContext
  * @throws BeansException
  */
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    SpringContextUtil.applicationContext = applicationContext;
  }
 
  /**
  * @return ApplicationContext
  */
  public static ApplicationContext getApplicationContext() {
    return applicationContext;
  }
 
  /**
  * 获取对象  
  * @param name
  * @return Object 一个以所给名字注册的bean的实例
  * @throws BeansException
  */
  public static Object getBean(String name) throws BeansException {
    return applicationContext.getBean(name);
  }
 
  /**
  * 获取类型为requiredType的对象
  * 如果bean不能被类型转换，相应的异常将会被抛出（BeanNotOfRequiredTypeException）
  * @param name       bean注册名
  * @param requiredType 返回对象类型
  * @return Object 返回requiredType类型对象
  * @throws BeansException
  */
  public static Object getBean(String name, Class requiredType) throws BeansException {
    return applicationContext.getBean(name, requiredType);
  }
 
  /**
  * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
  * @param name
  * @return boolean
  */
  public static boolean containsBean(String name) {
    return applicationContext.containsBean(name);
  }
 
  /**
  * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
  * 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）  
  * @param name
  * @return boolean
  * @throws NoSuchBeanDefinitionException
  */
  public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
    return applicationContext.isSingleton(name);
  }
 
  /**
  * @param name
  * @return Class 注册对象的类型
  * @throws NoSuchBeanDefinitionException
  */
  public static Class getType(String name) throws NoSuchBeanDefinitionException {
    return applicationContext.getType(name);
  }
 
  /**
  * 如果给定的bean名字在bean定义中有别名，则返回这些别名  
  * @param name
  * @return
  * @throws NoSuchBeanDefinitionException
  */
  public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
    return applicationContext.getAliases(name);
  }
}
 

action调用：
1234567891011121314151617181920212223242526272829303132333435363738 package com.anymusic.oa.webwork;
 
import java.util.List;
import java.util.Map;
 
import javax.servlet.http.HttpServletRequest;
 
import com.anymusic.oa.commons.service.ServiceLocator;
import com.anymusic.oa.hibernate.pojo.Role;
import com.anymusic.oa.hibernate.pojo.Users;
import com.anymusic.oa.spring.IUserService;
import com.opensymphony.webwork.ServletActionContext;
import com.opensymphony.xwork.Action;
import com.opensymphony.xwork.ActionContext;
import com.opensymphony.xwork.ModelDriven;
 
public class UserAction extends BaseAction implements Action,ModelDriven{
   
    private Users user = new Users();    
    UserService userService = (UserService) SpringContextUtil.getBean("userService");
   
    public String execute() throws Exception {        
        return SUCCESS;
    }
 
  public Object getModel() {
        return user;
    }    
   
    public String getAllUser(){
        HttpServletRequest request = ServletActionContext.getRequest();        
        List ls=userService.LoadAllObject( Users.class );
        request.setAttribute("user",ls);    
        this.setUrl("/yonghu.jsp");
        return SUCCESS;
    }
}
 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/d8111/archive/2008/08/31/2856601.aspx

Setup

Extract "jcom222.zip". And copy jcom.jar and jcom.dll to the following directories
jcom.dll -> (java.home)/bin/
jcom.jar -> (java.home)/lib/ext/
make sure the JAVA_HOME evironmental variable has been set, ie.
(java.home) == java.lang.System.getProperty("java.home");

import jp.ne.so_net.ga2.no_ji.jcom.ReleaseManager;
import jp.ne.so_net.ga2.no_ji.jcom.excel8.ExcelApplication;
import jp.ne.so_net.ga2.no_ji.jcom.excel8.ExcelWorkbook;
import jp.ne.so_net.ga2.no_ji.jcom.excel8.ExcelWorkbooks;
import jp.ne.so_net.ga2.no_ji.jcom.excel8.ExcelWorksheet;

public class JCom {

 public boolean print(String fname) {
  ReleaseManager rm = new ReleaseManager();
  try {
   ExcelApplication excel = new ExcelApplication(rm);

   ExcelWorkbooks xlBooks = excel.Workbooks();
   ExcelWorkbook xlBook = xlBooks.Open(fname);
   ExcelWorksheet xlSheet = excel.ActiveSheet();

   xlSheet.PrintOut();

   xlBook.Close(false, null, false);
   excel.Quit();
  } catch (Exception e) {
   e.printStackTrace();
   return false;
  } finally {
   rm.release();
  }
  return true;
 }

 public static void main(String[] args) {
  JCom test = new JCom();

  try {
   //test.p
   test.print("d:/test.xls");
   
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

import java.io.File;
import java.io.FilenameFilter;
import java.util.regex.Pattern;

/**
 * @author lin
 *
 */
public class DirList {
   //not using final in anonymous inner class
   public static FilenameFilter filter(final String regex){//注意此处的 final
    return new FilenameFilter(){
  private Pattern pattern = Pattern.compile(regex);
  public boolean accept(File dir, String name) {
          return  pattern.matcher(
         new File(name).getName()).matches();
  }   
    };
   }
 /**
  * @param args
  */
 public static void main(String[] args) {
  File path = new File(".");
  String [] list;
  if(args.length==0)
   list=path.list();
  else
   list=path.list(filter(args[0]));
  for(int i=0;i<list.length;i++)
   System.out.println(list[i]);
 }
}