面向对象方法课留了个作业，使用EJB实现一个简单的东东，从而更深刻的体会EJB组件。
虽然J2EE学了不少，但正统的EJB一直没有怎么看。今天大体看了看EJB3.0，感觉
EJB3.0在易用方面的确有很大的改进。曾经以极高的复杂性的EJB,现在和Spring、Hibernate
这些轻量级的解决方案相比已经差不了哪去了,EJB在轻量化，所有的Bean都可以是POJO的，只
需要使用注解表明是Entity bean,Stateless/Stateful Session bean,Message-driven bean,
Remote/Local接口,不需要实现特定的接口。Java Persistence已经从EJB中分离出来，作为一
个独立的标准JPA,而Hibernate是JPA的一个实现。这样Entity bean成为了可以脱离容器的普通
的POJO,JPA像JDBC那样可以在普通的应用程序的持久化中被使用。
     EJB容器提供的基础性服务(声明性事物管理、安全、并发控制、JNDI等)，使得受管的Bean受益于
这些服务的同时，这些Bean可以脱离容器而被测试，这在测试先行，敏捷开发流行的时代，尤为重要。
     EJB的资源管理为Bean进行了实例池化，这点感觉要比Spring依靠依赖注入的单例、原型等创建bean
相比具有更高的效率，像Stateless Session Bean、Message-Driven Bean都有若干个实例保存在池中，
可以同时相应多个请求，响应后在放入池中。而Stateful Session Bean则提供了钝化和激活操作，可
以在会话结束后钝化，将其状态保存在磁盘中，而在再次使用时，创建一个新的实例，将保存的状态拷
贝在这个新的实例中。这要比Spring简单的单例和原型要高效一些，当然随着JVM效率的提高，似乎对象
创建已经不太被看作是效率问题，像Web层的框架的应用控制器(Action)趋势是从单例到原型方式演进，
线程安全似乎更被重视。当然厂商对EJB容器的优化与直接Spring相比带来的优势是显然的。
     EJB与这些轻量级框架相比最大的优势是透明的分布式对象，这对于需要分布式的应用来说是最大的亮
点。分布式对象可以分布在不同的服务器上，从而使得应用程序具有很好的伸缩性。提供JDNI来查找定位
服务，虽然JDNI的lookup方式的定位服务没有依赖注入方式先进，但JDNI可以提供跨网络的服务定位。
     总体感觉EJB3和Spring等轻量级的解决方案相比，已经没有那么复杂的，EJB在轻量化，变得更易
用。Seam是个使用EJB3.0组合JSF的一站式的开发框架，整个的理念还很先进,不过入门门槛比较高。
对于使用EJB3来说Seam是个不错的选择。
 

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师

 Egothor 

 Nutch 

 Lucene 

 Oxyus 

 BDDBot 

 Zilverline 

 XQEngine 

 MG4J 

 JXTA Search 

 YaCy 

 Red-Piranha 

 LIUS 

 Aperture 

 Apache Solr 

 Paoding 

 Carrot2 

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

File.read('script.txt').scan(/[\s\?\.,'!]*\w+[\s\?\.,'!]*/m).each{|w| print w } 

• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• 第二届网络工程师侠客行大会5月24日杭州举行
• 北京: 千橡集团暨校内网诚聘软件研发工程师

 require "net/http" 

 class Fetcher
  
  def fetch(url)
    host = url.scan(/\/\/(.*?)\//m)[0][0]
    path = url.split(/#{host}\//)[1]
   # print "host: ",host,"\n"
   # print "path: ",path,"\n"
    h = Net::HTTP.new(host,80)
    resp = h.get("/#{path}",nil)
   
    if resp.message == "OK"
     # puts "建立连接成功..." 
      return resp.body     
    end 
    return ""
  end

end

class Parser
public
  def initialize()
    @fetcher = Fetcher.new
  end

  def parse_mp3(html)
    urls = html.scan(/<a href="(.*?)"/m)
    download_hosts_urls = {}
    parse_threads = []
    for url in urls do
        if url[0] =~ /.*?\.mp3,,.*?/
           parse_threads << Thread.new(url) do |url|
              song_url = url[0].gsub(" ","%20")
              download_url = parse_download_url(song_url)
              if download_url
              	host =  download_url.scan(/\/\/(.*?)\//m)[0][0] 
              	#We only want to find the best download url,so we needn't care duplicate key
              	download_hosts_urls[host] = download_url
              end 
           end
        end
    end
    parse_threads.each{|t| t.join}
    puts "已经搜索到#{download_hosts_urls.size}个链接可以下载..."
    exit(1) if download_hosts_urls.size == 0
    puts "正在选择速度最快的链接..."
    host = select_best_host(download_hosts_urls.keys)
    download_hosts_urls[host]
  end

private
  def select_best_host(hosts)
    times_hosts = {}
    threads = []
    hosts.each do |host|
      threads << Thread.new(host) do |host|
           response = `ping -c 1 -W 30 #{host}` #use`ping -n 1 -w 30 #{host}` in windows
           r_t = response.scan(/time=(\d+)/m) #only get integer part
           times_hosts[r_t[0][0]] = host unless r_t.empty? #duplicate key no problem 
      end
    end
   
    threads.each{|t| t.join}
   
    times = times_hosts.keys
    min = times.min
    times_hosts[min]
  end

  def parse_download_url(song_url)
     html = @fetcher.fetch(song_url)
     urls = html.scan(/<a href="(.*?)"/m)
     return nil if urls.empty? || urls[0][0] =~ /.*?\.html/
     return urls[0][0]      
  end
end

 require "open-uri"
require "parser"
require "fetcher"

class Download
public
  def initialize(song_name)
    @song_name = song_name
    @search_url = "http://mp3.baidu.com/m?f=ms&tn=baidump3&ct=134217728&lf=&rn=&word=#@song_name&lm=0"
    @parser = Parser.new
    @fetcher = Fetcher.new
  end
 
  def download
    puts "正在建立连接..."
    html = @fetcher.fetch(@search_url)
    puts "正在获取搜索结果..."
    url = @parser.parse_mp3(html)
    puts "已经获得最快的下载连接:#{url}.\n开始下载..."
    doDownload(url)    
    puts "下载完毕..."
  end
private
  def doDownload(url)
    open(url) do |fin|
  	size = fin.size
  	download_size = 0
  	puts "大小: #{size / 1024}KB"
  	filename = url[url.rindex('/')+1, url.length-1]
  	puts "歌曲名: #{filename}"
  	open(File.basename("./#{filename}"),"wb") do |fout|
     	    while buf = fin.read(1024) do
       		fout.write buf
       		download_size += buf.size
                print "已经下载： #{download_size * 100 / size}%\r"
                STDOUT.flush 
           end
       end
    end 
    puts
  end
end

download = Download.new(ARGV[0])
download.download

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师

require 'open-uri'

url = "http://www.union-ms.com/wenj/2005628171127.mp3"
open(url) do |fin|
  size = fin.size
  download_size = 0
  puts "size: #{size}"
  filename = url[url.rindex('/')+1, url.length-1]
  puts "name: #{filename}"
  open(File.basename("./#{filename}"),"wb") do |fout|
     while buf = fin.read(1024) do
       fout.write buf
       download_size += 1024
       #sleep(0.5)
       print "Downloaded #{download_size * 100 / size}%\r"
       STDOUT.flush 
    end
  end
end

• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师

package edu.jlu.fuliang;

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class RegexTest {
	public static void main(String[] args) {
		String regex = "\\w(\\d\\d)(\\w+)";
		String candidate = "x99SuperJava";
		
		Pattern p = Pattern.compile(regex);
		Matcher matcher = p.matcher(candidate);
		if(matcher.find()){
			int gc = matcher.groupCount();
			for(int i = 0; i <= gc; i++)
				System.out.println("group " + i + " :" + matcher.group(i));
		}
	}
}

import java.util.regex.*;

public class MatcherPatternExample{
  public static void main(String args[]){
      test();
  }

  public static void test(){
     Pattern p = Pattern.compile("\\d");
     Matcher m1 = p.matcher("55");
     Matcher m2 = p.matcher("fdshfdgdfh");

     System.out.println(m1.pattern() == m2.pattern());
     //return true
  }
}

public class MatcherStartExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Matcher and use the Matcher.start() method
     String candidateString = "My name is Bond. James Bond.";
     String matchHelper[] =
      {"          ^","                      ^"};
     Pattern p = Pattern.compile("Bond");
     Matcher matcher = p.matcher(candidateString);

     //Find the starting point of the first 'Bond'
      matcher.find();
      int startIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[0] + startIndex);

     //Find the starting point of the second 'Bond'
      matcher.find();
      int nextIndex = matcher.start();
      System.out.println(candidateString);
      System.out.println(matchHelper[1] + nextIndex);
}

import java.util.regex.*;

public class MatcherGroupExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
      //create a Pattern
      Pattern p = Pattern.compile("Bond");

      //create a Matcher and use the Matcher.group() method
      String candidateString = "My name is Bond. James Bond.";
      Matcher matcher = p.matcher(candidateString);
      //extract the group
      matcher.find();
      System.out.println(matcher.group());
  }
}

import java.util.regex.*;

public class MatcherGroupParamExample{
  public static void main(String args[]){
      test();
  }
  public static void test(){
     //create a Pattern
      Pattern p = Pattern.compile("B(ond)");

     //create a Matcher and use the Matcher.group(int) method
     String candidateString = "My name is Bond. James Bond.";
     //create a helpful index for the sake of output
     Matcher matcher = p.matcher(candidateString);
     //Find group number 0 of the first find
      matcher.find();
      String group_0 = matcher.group(0);
      String group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);

     //Find group number 1 of the second find
      matcher.find();
      group_0 = matcher.group(0);
      group_1 = matcher.group(1);
      System.out.println("Group 0 " + group_0);
      System.out.println("Group 1 " + group_1);
      System.out.println(candidateString);
  }
}

 while(matcher.find()){
    //在匹配的区域，使用group,replace等进行查看和替换操作
 }

StringBuffer sb = new StringBuffer();
String replacement = "Smith";
Pattern pattern = Pattern.compile("Bond");
Matcher matcher =pattern.matcher("My name is Bond. James Bond. I would like a martini.");
while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}

while(matcher.find()){
  matcher.appendReplacement(sb,replacement);//结果是My name is Smith. James Smith
}
matcher.appendTail(sb);

public String replaceFirst(String replacement)

• 搜狐网站诚聘Java、PHP和C++工程师
• 第二届网络工程师侠客行大会5月24日杭州举行
• 北京: 千橡集团暨校内网诚聘软件研发工程师

EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setAllowCreate(true);
myDbEnvironment = new Environment(new File("/export/dbEnv"),
envConfig);

Environment myEnv = new Environment(new File("/export/dbEnv"), null);
EnvironmentMutableConfig envMutableConfig =
new EnvironmentMutableConfig();
envMutableConfig.setTxnNoSync(true);
myEnv.setMutableConfig(envMutableConfig);

long cacheMisses = myEnv.getStats(null).getNCacheMiss();

List myDbNames = myDbEnv.getDatabaseNames();
for(int i=0; i < myDbNames.size(); i++) {
System.out.println("Database Name: " + (String)myDbNames.get(i));
}

String dbName = myDB.getDatabaseName();
myDB.close();
myDBEnv.removeDatabase(null,dbName);

String dbName = myDB.getDatabaseName();
String dbNewName = new String(dbName + ".new", "UTF-8");
myDB.close();
myDBEnv.renameDatabase(null,dbName,dbNewName);

myEnv.truncate(null, // txn handle
myDatabase.getDatabaseName(), // database name
true//whether to return the count of deleted records
);

EnvironmentConfig envConfig = new EnvironmentConfig();
envConfig.setAllowCreate(true);
myDbEnvironment = new Environment(new File("/export/dbEnv"), envConfig);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
myDatabase = myDbEnvironment.openDatabase(null,
"sampleDatabase",
dbConfig);

String aKey = "key";
String aData = "data";
try {
DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));
} catch (Exception e) {
}

String aKey = "myFirstKey";
String aData = "myFirstData";
try {
DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));
myDatabase.put(null, theKey, theData);
} catch (Exception e) {
}

String aKey = "myFirstKey";
try {
DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry();

if (myDatabase.get(null, theKey, theData, LockMode.DEFAULT) ==
OperationStatus.SUCCESS) {

byte[] retData = theData.getData();
String foundData = new String(retData, "UTF-8");
System.out.println("For key: '" + aKey + "' found data: '" +
foundData + "'.");
} else {
  System.out.println("No record found for key '" + aKey + "'.");
}
} catch (Exception e) {
}

String aKey = "myFirstKey";
DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
myDatabase.delete(null, theKey);

package edu.jlu.fuliang;

import java.io.File;

import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.je.LockMode;

import junit.framework.TestCase;

public class PrimitiveBindingTest extends TestCase{
	private Environment env;
	private Database db;
	private String key = "akey";
	private Long data = 1234556633L;
	
	public void setUp()throws Exception{
		EnvironmentConfig envConfig = new EnvironmentConfig();
		envConfig.setAllowCreate(true);
		env = new Environment(new File("etc/dbEnv"),envConfig);
		DatabaseConfig dbConfig = new DatabaseConfig();
		dbConfig.setAllowCreate(true);
		db = env.openDatabase(null, "myDB", dbConfig);
		DatabaseEntry keyEntry = new DatabaseEntry(key.getBytes("UTF-8"));
		DatabaseEntry dataEntry = new DatabaseEntry();
		
		EntryBinding myBinding = TupleBinding.getPrimitiveBinding(Long.class);
	    myBinding.objectToEntry(data, dataEntry);
	    db.put(null, keyEntry, dataEntry);
	}
	
	public void testGet()throws Exception{
		DatabaseEntry keyEntry = new DatabaseEntry(key.getBytes("UTF-8"));
		DatabaseEntry dataEntry = new DatabaseEntry();
		EntryBinding binding = TupleBinding.getPrimitiveBinding(Long.class);
		db.get(null, keyEntry, dataEntry, LockMode.DEFAULT);
		Long l = (Long)binding.entryToObject(dataEntry);
		assertEquals(l,data);
	}
	public void tearDown()throws Exception{
		db.close();
		env.truncateDatabase(null, "myDB",false);
		env.close();
	}
	
}

package edu.jlu.fuliang;

import java.io.File;

import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.je.LockMode;

import junit.framework.TestCase;

public class SerializableTypeTest extends TestCase{
	private Person person;
	private Environment env;
	private Database db,classDB;
	private StoredClassCatalog classCatalog;
	
	public void setUp()throws Exception{
		person = new Person();
		person.setAge(12);
		person.setName("zhansan");
		person.setSex('m');
	    
		EnvironmentConfig envConfig = new EnvironmentConfig();
		envConfig.setAllowCreate(true);
		env = new Environment(new File("etc/dbEnv"),envConfig);
		DatabaseConfig dbConfig = new DatabaseConfig();
		dbConfig.setAllowCreate(true);
		db = env.openDatabase(null, "myDB", dbConfig);
		classDB = env.openDatabase(null, "classDB", dbConfig);
		classCatalog = new StoredClassCatalog(classDB);
		EntryBinding dataBinding = new SerialBinding(classCatalog,Person.class);
			
		DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));
		DatabaseEntry dataEntry = new DatabaseEntry();
		dataBinding.objectToEntry(person, dataEntry);
		db.put(null, keyEntry, dataEntry);
	}
	
	public void testGet()throws Exception{
		EntryBinding dataBinding = new SerialBinding(classCatalog,Person.class);
	  
		DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));
	    DatabaseEntry dataEntry = new DatabaseEntry();
	    db.get(null, keyEntry, dataEntry, LockMode.DEFAULT);
	    Person p = (Person)dataBinding.entryToObject(dataEntry);
	    assertEquals(p.getName(),person.getName());
	    assertEquals(p.getAge(),person.getAge());
	    assertEquals(p.getSex(), person.getSex());
	}
	
	public void tearDown()throws Exception{
		db.close();
		classDB.close();
		env.truncateDatabase(null, "myDB", false);
		env.truncateDatabase(null, "classDB", false);
		env.close();
	}
}

package edu.jlu.fuliang;

import java.io.Serializable;

public class Person implements Serializable{
	private String name;
	private int age;
	private char sex;

	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 char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}
}

package edu.jlu.fuliang;

import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.bind.tuple.TupleInput;
import com.sleepycat.bind.tuple.TupleOutput;

public class PersonTupleBinding extends TupleBinding{

	@Override
	public Object entryToObject(TupleInput ti) {
		Person person = new Person();
		person.setName(ti.readString());
		person.setAge(ti.readInt());
		person.setSex(ti.readChar());
		return person;
	}

	@Override
	public void objectToEntry(Object obj, TupleOutput output) {
		Person person = (Person)obj;
		output.writeString(person.getName());
		output.writeInt(person.getAge());
		output.writeChar(person.getSex());
	}
}

package edu.jlu.fuliang;

import java.io.File;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.je.LockMode;

import junit.framework.TestCase;

public class CustomTupleBindingTest extends TestCase{
	private Person person;
	private Environment env;
	private Database db;
	
	public void setUp()throws Exception{
		person = new Person();
		person.setAge(12);
		person.setName("zhansan");
		person.setSex('m');
	    
		
		EnvironmentConfig envConfig = new EnvironmentConfig();
		envConfig.setAllowCreate(true);
		env = new Environment(new File("etc/dbEnv"),envConfig);
		DatabaseConfig dbConfig = new DatabaseConfig();
		dbConfig.setAllowCreate(true);
		db = env.openDatabase(null, "myDB", dbConfig);
		PersonTupleBinding binding = new PersonTupleBinding();
		DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));
		DatabaseEntry dataEntry = new DatabaseEntry();
		binding.objectToEntry(person, dataEntry);
		db.put(null, keyEntry, dataEntry);
		
	}
	
	public void testGet()throws Exception{
		PersonTupleBinding binding = new PersonTupleBinding();
	    
		DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));
	    DatabaseEntry dataEntry = new DatabaseEntry();
	    db.get(null, keyEntry, dataEntry, LockMode.DEFAULT);
	    Person p = (Person)binding.entryToObject(dataEntry);
	    assertEquals(p.getName(),person.getName());
	    assertEquals(p.getAge(),person.getAge());
	    assertEquals(p.getSex(), person.getSex());
	}
	public void tearDown()throws Exception{
		db.close();
		env.truncateDatabase(null, "myDB", false);
		env.close();
	}
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

package edu.jlu.fuliang;

import org.springframework.stereotype.Component;

@Component
public class MessageProvider {
	private String message = "Hello World!";

	public String getMessage() {
		return message;
	}

	public void setMessage(String message) {
		this.message = message;
	}
}

package edu.jlu.fuliang;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessageRender {
	private MessageProvider messageProvider;

	@Autowired
	public void setMessageProvider(MessageProvider messageProvider) {
		this.messageProvider = messageProvider;
	}
	
	public void render(){
		System.out.println(messageProvider.getMessage());
	}
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context-2.5.xsd">
    <context:component-scan base-package="edu.jlu.fuliang"/>
</beans>

<context:component-scan base-package="com.baobaotao">
    <context:include-filter type="regex" 
        expression="edu\.jlu\.fuliang\.service\..*"/>
    <context:exclude-filter type="aspectj" 
        expression="edu.jlu.fuliang.util..*"/>
</context:component-scan>

package edu.jlu.fuliang;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorld {
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});
		MessageRender render = (MessageRender) context.getBean("messageRender");
		render.render();
	}
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

package edu.jlu.fuliang;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class ProblemTest extends JFrame{
   private JTextArea textArea = new JTextArea(10,10);
   private JButton startButton = new JButton("Start");
     
   public ProblemTest(){
	   JPanel panel = new JPanel();
	   panel.setLayout(new BorderLayout());
	   panel.add(new JScrollPane(textArea),BorderLayout.CENTER);
	   panel.add(startButton,BorderLayout.NORTH);
	   startButton.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e) {
               　　　 ProblemTest.this.append();	
		}
	   });
	  add(panel);
	   setSize(300,300);
	   setVisible(true);
   }
  
   public void append() {
		for (int i = 0; i < 20; i++) {
			textArea.append("Line " + i + "\n");
			try {
				Thread.currentThread().sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}  
   public static void main(String[] args) {
	   ProblemTest pt = new ProblemTest();
	   pt.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }
}

public void actionPerformed(ActionEvent e) {
         ProblemTest.this.append();	
}

package edu.jlu.fuliang;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class ProblemTest extends JFrame{
   private JTextArea textArea = new JTextArea(10,10);
   private JButton startButton = new JButton("Start");
   private Thread thread =  null; 
   
   public ProblemTest(){
	   JPanel panel = new JPanel();
	   panel.setLayout(new BorderLayout());
	   panel.add(new JScrollPane(textArea),BorderLayout.CENTER);
	   panel.add(startButton,BorderLayout.NORTH);
	   startButton.addActionListener(new ActionListener(){
		public void actionPerformed(ActionEvent e) {
               // ProblemTest.this.append();	
			 thread.start();
		}
	   });
	   thread = new Thread(){
			  public void run(){
				  append();
			  }
	   };
	   add(panel);
	   setSize(300,300);
	   setVisible(true);
   }
  
   public void append() {
		for (int i = 0; i < 20; i++) {
			textArea.append("Line " + i + "\n");
			try {
				Thread.currentThread().sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}  
   public static void main(String[] args) {
	   ProblemTest pt = new ProblemTest();
	   pt.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }
}

• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

package edu.jlu.fuliang;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Eval {
   public int eval(String exp){
	   List<String> list = infixExpToPostExp(exp);//转化成后缀表达式
	   return doEval(list);//真正求值
   }
   
   //遇到操作符压栈，遇到表达式从后缀表达式中弹出两个数，计算出结果，压入堆栈
   private int doEval(List<String> list) {
	  Stack<String> stack =  new Stack<String>();
	  String element;
	  int n1,n2,result;
	  try{
		  for(int i = 0; i < list.size();i++){
			  element = list.get(i);
			  if(isOperator(element)){
				  n1 = Integer.parseInt(stack.pop());
				  n2 = Integer.parseInt(stack.pop());
				  result = doOperate(n1,n2,element);
				  stack.push(new Integer(result).toString());
			 }else{
				 stack.push(element);
			 }
		  }
		  return Integer.parseInt(stack.pop());
	  }catch(RuntimeException e){
		  throw new IllegalExpressionException(e.getMessage()); 	  
	  }
   }
   
   private int doOperate(int n1, int n2, String operator) {
      if(operator.equals("+"))
    	  return n1 + n2;
      else if(operator.equals("-"))
    	  return n1 - n2;
      else if(operator.equals("*"))
    	  return n1 * n2;
      else
          return n1 / n2;
   }

   private boolean isOperator(String str){
	   return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");
   }
   
   private List<String> infixExpToPostExp(String exp){//将中缀表达式转化成为后缀表达式
	   List<String> postExp = new ArrayList<String>();//存放转化的后缀表达式的链表
	   StringBuffer numBuffer = new StringBuffer();//用来保存一个数的
	   Stack<Character> opStack = new Stack<Character>();//操作符栈
	   char ch,preChar;
	   opStack.push('#');
	   try{
		   for(int i = 0; i < exp.length();){
			   ch = exp.charAt(i);
			   switch(ch){
			   		case '+':
			   		case '-':
			   		case '*':
			   		case '/':
			   			preChar = opStack.peek();
//		    	如果栈里面的操作符优先级比当前的大，则把栈中优先级大的都添加到后缀表达式列表中
			   			while(priority(preChar) >= priority(ch)){
			   				postExp.add(""+preChar);
			   				opStack.pop();
			   				preChar = opStack.peek();
			   			}
			   			opStack.push(ch);
			   			i++;
			   			break;
			   		case '(':
//	            左括号直接压栈
			   			opStack.push(ch);
			   			i++;
			   			break;
			   		case ')':
//		    	右括号则直接把栈中左括号前面的弹出，并加入后缀表达式链表中
			   			char c = opStack.pop();
			   			while(c != '('){
			   				postExp.add("" + c);
			   				c = opStack.pop();
			   			}
			   			i++;
			   			break;
//		     #号，代表表达式结束，可以直接把操作符栈中剩余的操作符全部弹出，并加入后缀表达式链表中
			     case '#':
			    	 char c1;
			    	 while(!opStack.isEmpty()){
			    		 c1 = opStack.pop();
			    		 if(c1 != '#')
			    		   postExp.add("" + c1);
			    	 }
			    	 i++;
			    	 break;
	                          //过滤空白符
			     case ' ':
			     case '\t':
			    	 i++;
			    	 break;
//		    	 数字则凑成一个整数，加入后缀表达式链表中
			     default:
			    	 if(Character.isDigit(ch)){
			    		 while(Character.isDigit(ch)){
			    			 numBuffer.append(ch);
			    		     ch = exp.charAt(++i);
			    		 }
			             postExp.add(numBuffer.toString());
			             numBuffer = new StringBuffer();
			    	 }else{
			    		 throw new IllegalExpressionException("illegal operator");
			    	 }
			   }
		   }
	   }catch(RuntimeException e){
		   throw new IllegalExpressionException(e.getMessage()); 
	   }
	   return postExp;
   }
   
   private int priority(char op){//定义优先级
		switch(op){
	   	case'+':
	   	case'-':
	   		return 1;
	   	case'*':
	   	case'/':
	   		return 2;
	   	case'(':
	   	case'#':
	        return 0;
	   	}
		throw new IllegalExpressionException("Illegal operator");
  }
   
   public static void main(String[] args) {
	   Eval eval = new Eval();
	   int result = eval.eval("2+3+55*22+21*2+(3+2)*3+4*3+3*4#");
	   System.out.println(result);
   }
}

package edu.jlu.fuliang;

public class IllegalExpressionException extends RuntimeException{
    
	public IllegalExpressionException(){
		
    }
    
    public IllegalExpressionException(String info){
    	super(info);
    }
}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

void f(BaseType bt){
  //使用bt来做事情
}

public class Rectangle{
  protected int width;
  protected int hight;
 
  public void setWidth(int width){
     this.width = width; 
  }
  public void setHight(int hight){
     this.hight = hight;
 }
 public int getWidth(){
    return width;
 }
 public int getHight(){
   return hight;
 }
}

public class Square extends Rectangle{
//others
 public void setWidth(int width){
     super.setWidth(width);
     super.setHight(width);
 }
  public void setHight(int hight){
     super.setHight(hight);
     super.setWidth(hight);
 }
}

void testArea(Rectangle r){
  r.setWidth(2);
  r.setHeight(3);
  assert(r.area()==6);
}

• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

import java.util.regex.*;

public class FindA{
  public static void main(String args[])
  throws Exception{

    String candidate =
     "A Matcher examines the results of applying a pattern.";
    String regex = "\\ba\\w*\\b";
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(candidate);
    String val = null;
    System.out.println("INPUT: " + candidate);
    System.out.println("REGEX: " + regex +"\r\n");
    while (m.find()){
      val = m.group();
      System.out.println("MATCH: " + val);
    }
    if (val == null) {
      System.out.println("NO MATCHES: ");
    }
  }
}

Pattern p = Pattern.compile(regex);

 Matcher m = p.matcher(candidate);

String regex = "\\ba\\w*\\b";

static Pattern compile(String regex) 

 
static Pattern compile(String regex, int flags) 

Pattern p =Pattern.compile("A    #matches uppercase US-ASCII char code 65",Pattern.COMMENTS);

Pattern p = Pattern.compile("^", Pattern.MULTILINE);

Pattern p = Pattern.compile(".", Pattern.DOTALL);

Pattern p =
Pattern.compile("t # a compound flag example",Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE|
Pattern.COMMENT);

Pattern p = Pattern.compile("\d");

Pattern p = Pattern.compile("\\d");

public int flags()

int flgs = myPattern.flags();
boolean isUsingCommentFlag =( Pattern.COMMENTS == (Pattern.COMMENTS & flgs)) ;

public static boolean matches (String regex,CharSequence input)

 Pattern p = Pattern.compile(regex);
 Matcher m = p.matcher(candidate);
 m.matches()

 Pattern p = new Pattern.compile(",|and");
 String fruits[] = p.split("apple,banana and orange");

public String[] split(CharSequence input, int limit)

String[] tmp = pattern.split("Hello, Dolly, You, Are, My, Favorite",3);
//tmp[0] is  "Hello",
// tmp[1] is "Dolly";
//tmp[2] is  "You, Are, My, Favorite";

Pattern p = Pattern.compile(",");
String temp[] = p.split("Hello,Dolly,", -1);
//temp[]={"Hello","Dolly",""}

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

 public interface Sort<T>{
    void sort(T t[]);
 }
 public class BubbleSort<T> implements BubbleSort<T>{
   public void sort(T t[]){
     //the bubble sort code
   }
 }

 public class QuickSort<T> implements BubbleSort<T>{
   public void sort(T t[]){
     //the quick sort code
   }
 }

 class SomeClassUseSort{
   private Sort sort;
   //other codes
 }

class Shape{}
class Circle extends Shape{}
class Square extends Shape{}

class DrawAll{
 public void drawAll(List<Shape> shapes){  
   for(Shape shape : shapes){
      if(shape instanceof Circle)
          drawCircle();
       else if(shape instanceof Square){
          drawSquare();
       }    
   }
 }
 private void drawCircle(){
   //draw circle;
 }
 private void drawSquare(){
   //draw square
 }
}

class Shape{
 public abstract void draw();
}
class Circle extends Shape{
  public void draw(){
   //draw circle
  }
}
class Square extends Shape{
  public void draw(){
    //draw Shape
  }
}
class DrawAll{
  public void drawAll(List<Shape> shapes){  
   for(Shape shape : shapes){
      shape.draw();
   }
  }
}

interface DrawAll{
  public abstract void drawAll(List<Shape> shapes);
}

class DrawAllByListIndex　implements DrawAll{
  public void drawAll(List<Shape> shapes){  
   for(Shape shape : shapes){
      shape.draw();
   }
  }
}

class DrawAllByShape implements DrawAll{
   public void drawAll(List<Shape> shapes){ 
   sortByShape(shapes); 
   for(Shape shape : shapes){
      shape.draw();
   }
  }
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 第二届网络工程师侠客行大会5月24日杭州举行

class Rectangle{
  public void draw();
  public double area();
}

class GeometricRantangle{
  public double area();
}
class GUIRectangle(){
  public void draw();
}

interface Moderm{
  public void dial(String pno);
  public void hangup();
  public void send(char c);
  public void recv();
}

interface Connection{
 public void dial(String pno);
 public void hangup();
}

interface Channel{
  public void send(char c);
  public void recv();
}
class Moderm implements Connection,Channel{
  //...
}

• 第二届网络工程师侠客行大会5月24日杭州举行
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师