public interface IStudent {

    public void addStudent(String name);
}

/////////////////////////

public class StudentImpl implements IStudent {

    public void addStudent(String name) {
        System.out.println(" 欢迎  " + name + "  你加入Spring家庭! ");
    }
}

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class CompareInterceptor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable{
        Object result = null;
        String stu_name = invocation.getArguments()[0].toString();
        if ( stu_name.equals("dragon")){
            //如果学生是dragon时,执行目标方法,
            result= invocation.proceed();

        } else{
            System.out.println("此学生是"+stu_name+"而不是dragon,不批准其加入.");
        }

        return result;
    }
}

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

/**
 * 前置通知:BeforeAdvice.java
 */
public class BeforeAdvice implements MethodBeforeAdvice {

    public void before(Method method, Object[] args, Object target)
            throws Throwable {

        System.out.println(" 这是BeforeAdvice类的before方法. ");

    }
}

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

/**
 * 后置通知:AfterAdvice.java
 */
public class AfterAdvice implements AfterReturningAdvice {

    public void afterReturning(Object returnValue, Method method,
                               Object[] args, Object target) throws Throwable {
        System.out.println("这是AfterAdvice类的afterReturning方法.");
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

    <bean id="beforeAdvice" class="com.dragon.study.BeforeAdvice"></bean>
    <bean id="afterAdvice" class="com.dragon.study.AfterAdvice"></bean>
    <bean id="compareInterceptor" class="com.dragon.study.CompareInterceptor"></bean>
    <bean id="studenttarget" class="com.dragon.study.StudentImpl"></bean>

    <bean id="student" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.dragon.study.IStudent</value>
        </property>
        <property name="interceptorNames">
            <list>
                <value>beforeAdvice</value>
                <value>afterAdvice</value>
                <value>compareInterceptor</value>
            </list>
        </property>
        <property name="target">
            <ref bean="studenttarget"/>
        </property>

    </bean>


</beans>

public class DebugProxy implements java.lang.reflect.InvocationHandler
{
    private Object obj;

    public static Object newInstance(Object obj)
    {
        return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new DebugProxy(obj));
    }

    private DebugProxy(Object obj)
    {
        //Greet接口的實現：GreetImpl
        this.obj = obj;
    }

    //Method m：調用的方法
    //Object[] args：方法要傳入的參數
    public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
    {
        Object result;
        try
        {
            //自定義的處理
            System.out.println("--before method " + m.getName());
            //調用GreetImpl中方法
            result = m.invoke(obj, args);
        }
        catch(InvocationTargetException e)
        {
            throw e.getTargetException();
        }
        catch(Exception e)
        {
            throw new RuntimeException("unexpected invocation exception: " + e.getMessage());
        }
        finally
        {
            System.out.println("--after method " + m.getName());
        }
        return result;
    }

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        Greet tmp = new GreetImpl();

        Greet greet = (Greet) DebugProxy.newInstance(tmp);
        //生成的greet和tmp有相同的hashCode

        greet.sayHello("walter");
        greet.goodBye();
    }
}

public class SimpleProxy implements Greet {
    private Greet greet = null;

    public SimpleProxy(Greet greet) {
        this.greet = greet;
    }

    public void sayHello(String name) {
        System.out.println("--before method sayHello");
        greet.sayHello(name);
        System.out.println("--after method sayHello");
    }

    public void goodBye() {
        System.out.println("--before method goodBye");
        greet.goodBye();
        System.out.println("--after method goodBye");
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Greet greet = new SimpleProxy(new GreetImpl());//生成代理
        greet.sayHello("walter");
        greet.goodBye();
    }
}

//1、基类
public interface Greet {
    public void sayHello(String name);

    public  void goodBye();
}

//2、实现类
public class GreetImpl implements Greet
{
    public void sayHello(String name)
    {
        System.out.println("Hello " + name);
    }

    public void goodBye()
    {
        System.out.println("Good bye.");
    }
}

//1、接口
public interface Work {
    public void insert();

}

//2、实现类
public class SquarePeg implements Work {
    public void insert() {
        System.out.println("方形桩插入");
    }

}

//3、代理类
public class Decorator implements Work {

    private Work work =null;
    //额外增加的功能被打包在这个List中
    private ArrayList others = new ArrayList();

    //在构造器中使用组合new方式,引入Work对象;
    public Decorator(Work work) {
        this.work = work;

        others.add("挖坑");

        others.add("钉木板");
    }

    public void insert() {
        newMethod();
    }


    //在新方法中,我们在insert之前增加其他方法,这里次序先后是用户灵活指定的
    public void newMethod() {
        otherMethod();
        work.insert();


    }

    public void otherMethod() {
        ListIterator listIterator = others.listIterator();
        while (listIterator.hasNext()) {
            System.out.println(((String) (listIterator.next())) + " 正在进行");
        }

    }
    public static void main(String[] args) {
        Work work = new Decorator(new SquarePeg());
        work.insert();

    }
}

 /**
     * 一个字符串，找出这个字符串的第一对重复的字符
     * 如  abcdefgjikuoa   第一对重复的字符是’a’
     * 如   abcdegfeter 第一对重复的字符  ‘e’
     * <p/>
     * 找个hash map往里存，如果发现已经有值了就是找到了第一对，时间复杂度o(n)
     */
    public static void QuickFind() {
        String s = "kdaduasdasda";
        String re = null;
        Map map = new HashMap();
        //char[] ch = s.toCharArray();

        for (int i = 0; i < s.length(); i++) {
            String key = s.substring(i, i + 1);
            if (map.get(key) != null) {
                re = key;
                break;
            } else {
                map.put(key, 0);
            }
        }

        if (re != null) {
            System.out.println("The char is " + re);
        } else {
            System.out.println("There is no char!");
        }
    }

package com.dragon.study;

import java.util.*;

/**
 * 发牌算法的实现
 * 要求：把2副牌，也就是108张，发给4个人，留6张底牌
 */
public class Exec {
    public static void main(String[] args) {
        //存储108张牌的数组
        int[] total = new int[108];
        //存储四个玩家的牌
        int[][] player = new int[4][25];
        //存储当前剩余牌的数量
        int leftNum = 108;
        //随机数字
        int ranNumber;
        //随机对象
        Random random = new Random();

        //初始化数组
        for (int i = 0; i < total.length; i++) {
            total[i] = (i + 1) % 54;
            //处理大小王编号
            if (total[i] == 0) {
                total[i] = 54;
            }


        }
        //循环发牌
        for (int i = 0; i < 25; i++) {
            //为每个人发牌
            for (int j = 0; j < player.length; j++) {
                //生成随机下标
                ranNumber = random.nextInt(leftNum);
                //发牌
                player[j][i] = total[ranNumber];
                //移动已经发过的牌
                total[ranNumber] = total[leftNum - 1];
                //可发牌的数量减少1
                leftNum--;
            }
        }


        //循环输出玩家手中的牌
        for (int i = 0; i < player.length; i++) {
            for (int j = 0; j < player[i].length; j++) {
                System.out.print("  " + player[i][j]);
            }
            System.out.println();

        }

        //底牌
        for (int i = 0; i < 8; i++) {
            System.out.print("  " + total[i]);
        }
        System.out.println();

    }

}

<!--?xml version="1.0" encoding="UTF-8"?-->
<waiterroot>
    <waiter>
        <id>0</id>
        <type>笑傲江湖</type>
        <name>zdz</name>
    </waiter>
    <waiter>
        <id>1</id>
        <type>天龙八部</type>
        <name>zdz</name>
    </waiter>
    <waiter>
        <id>2</id>
        <type>神雕侠侣</type>
        <name>zdz</name>
    </waiter>
    <waiter>
        <id>3</id>
        <type>笑傲江湖</type>
        <name>zdz</name>
    </waiter>
    <waiter>
        <id>4</id>
        <type>风云争霸</type>
        <name>zdz</name>
    </waiter>
    <waiter>
        <id>5</id>
        <type>神雕侠侣</type>
        <name>zdz</name>
    </waiter>
</waiterroot>

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

public class Test {

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

        SAXReader sax = new SAXReader();
        File f = new File("data.xml");
        Document doc = sax.read(f);
        Element root = doc.getRootElement();
        Map map = new HashMap();

        for(Iterator it = root.elementIterator();it.hasNext();){
            Element element = (Element) it.next();//waiter

            for ( Iterator it2 = element.elementIterator(); it2.hasNext(); ) {
                  Element elementInner = (Element) it2.next();
                  if(elementInner.getName().equals("type")){
                      String size =  (String) map.get(elementInner.getText());
                      if(size != null){
                          int i = Integer.parseInt(size)+1;
                          map.put(elementInner.getText(),String.valueOf(i));
                      }else{
                          map.put(elementInner.getText(),String.valueOf(1));
                      }
                  }
           }
        }

        Set set = map.entrySet();
        Iterator it3 = set.iterator();
        while(it3.hasNext()){
            System.out.println(it3.next());
        }
    }

}
==================== 伪代码 =======================
解析器定义
读入Xml文件，获得Doc
定义存放key-value容器m
获得Xml文件的最上面的根
如果根目录Element未结束，递归
  如果节点Note未结束，递归
    如果节点名为“type”
    定义从容器m中取出key等于当前element节点值的Valuem
    如果Valuem为空，容器m放入key为当前element节点值，value为1的元素；
    如果valuem不为空，容器m放入key为当前element节点值，value为1+整数化(Valuem)的元素；
输出m

package com.dragon.study;

class Account {
    String name;
    float amount;


    public Account(String name, float amount) {
        this.name = name;
        this.amount = amount;
    }

    public synchronized  void deposit(float amt) {
        float tmp = amount;
          tmp += amt;

        try {
            Thread.sleep(1);//模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) {
            // ignore
        }

        amount = tmp;
    }

    public synchronized void withdraw(float amt) {
        float tmp = amount;
       tmp -= amt;

        try {
            Thread.sleep(13);//模拟其它处理所需要的时间，比如刷新数据库等
        } catch (InterruptedException e) {
            // ignore
        }

        amount = tmp;
    }

    public float getBalance() {
        return amount;
    }
}


public class AccountTest {
    private static int NUM_OF_THREAD = 1000;
    static Thread[] threads = new Thread[NUM_OF_THREAD];

    public static void main(String[] args) {
        long i_Begin = (System.currentTimeMillis());

        final Account acc = new Account("John", 1000.0f);
        for (int i = 0; i < NUM_OF_THREAD; i++) {
            threads[i] = new Thread(new Runnable() {
                public void run() {
                    acc.deposit(100.0f);
                    acc.withdraw(100.0f);
                }
            });
            threads[i].start();
        }

        for (int i = 0; i < NUM_OF_THREAD; i++) {
            try {
                threads[i].join(); //等待所有线程运行结束
            } catch (InterruptedException e) {
                // ignore
            }
        }
        System.out.println("Finally, John's balance is:" + acc.getBalance());
        long i_End = (System.currentTimeMillis());
        System.out.println("判断用户耗时：" + (i_End - i_Begin));

    }

}

package com.dragon.study.socket;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

public class HelloMessage extends Thread {

    private Socket socket_ = null;

    public HelloMessage(Socket socket) {

        this.socket_ = socket;

        this.start();

    }

    public void run() {

        try {

            BufferedReader bReader = new BufferedReader(new InputStreamReader(

                    this.socket_.getInputStream()));

            PrintWriter pWriter = new PrintWriter(this.socket_

                    .getOutputStream());

            String requestStr = bReader.readLine();

            if (requestStr != null && !"".equals(requestStr)) {

                if (requestStr.equals("java")) {

                    pWriter.println("your write is java");

                }

                if (requestStr.equals(".net")) {

                    pWriter.println("your write is .net");

                }

                if (requestStr.equals("php")) {

                    pWriter.println("your write is php");

                }

                if (requestStr.equals("end")) {

                    pWriter.println("your write is end");

                } else {

                    pWriter.println("your write is other");

                }

            } else {

                pWriter.println("your write is null");

            }

            pWriter.flush();

            pWriter.close();

            bReader.close();

            this.socket_.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

package com.dragon.study.socket;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

public class ClientSocket {

    public static void main(String[] args) {

        clientRequest();

    }

    private static void clientRequest() {

        try {

            while (true) {

                Socket clientSocket = new Socket("127.0.0.1", 3456);

                BufferedReader bReader = new BufferedReader(new InputStreamReader(

                        System.in));

                System.out.println("please input java or .net or php or end");

                String strLine = bReader.readLine();

                if (strLine != null && !"".equals(strLine)) {

                    PrintWriter pWriter = new PrintWriter(clientSocket

                            .getOutputStream(), true);

                    pWriter.println(strLine);

                    BufferedReader br = new BufferedReader(

                            new InputStreamReader(clientSocket.getInputStream()));

                    String strResult = br.readLine();

                    System.out.println(strResult);

                    pWriter.flush();

                    pWriter.close();

                    clientSocket.close();

                }

            }

        } catch (UnknownHostException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}

package com.dragon.study.socket;

import java.io.IOException;

import java.net.InetAddress;

import java.net.Socket;

public class ServerSocket {

    public static void main(String[] args) {

        beginSocket();

    }

    public static void beginSocket() {

        try {

            java.net.ServerSocket serverSocket = new java.net.ServerSocket(3456);

            InetAddress inta = serverSocket.getInetAddress().getLocalHost();

            System.out.println(inta.getHostAddress());

            while (true) {

                Socket socket = serverSocket.accept();

                new HelloMessage(socket);

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}