day25 注解技术 动态代理 servlet3.0 线程池

Java基础加强第一天 ： JDJava基础加强第一天 ： JDK5.0新特性（泛型、枚举、for/in、可变参数、自动装箱拆箱、静态导入） + 反射 API（Class、Construtctor 、Field、Method ）
字符串格式化 StringFormat、System.out.printf
注解技术
线程并发库

Java基础加强第二天 ：上午：注解技术使用 @override ----- Servlet3.0 新特性 （之前课程中2.5 特性） 、动态代理技术（方法增强三种方式）
下午：复习线程基础知识、多线程编写案例 、Java5 提供线程并发库 线程池 、Socket网络编程（自定义服务器案例 tomcat）

Java Annotation 注解技术 是java5.0 新特性 （如果编译环境是java1.4 之前版本 无法对注解进行编译）

JDK官方提供了三个注解
@Override: 限定重写父类方法, 该注解只能用于方法 ------ 编译时检查，不构成覆盖 报错
* JDK5.0 override注解只能用于方法覆盖 JDK6.0 该注解可以用于接口的方法实现
@Deprecated: 用于表示某个程序元素(类, 方法等)已过时 ----- 在编译器进行编译时 报出一个警告
* 为什么会有过时方法： 提供了新的方法取代 之前方法、发现某个方法存在安全隐患，不建议用户再使用
@SuppressWarnings: 抑制编译器警告.  ---- 通知编译器在编译时 不要报出警告信息
* 使用 all 忽略所有警告信息
@SuppressWarnings("all")
    // 抑制警告信息 类型
    public static void main(String[] args) {
        int a;

        List list = new ArrayList();

        Thread t = new Thread();
        t.start();
        t.stop();// 删除线，因为stop 方法已经过时

        show();
    }

    // 通过deprecated 使 show 方法过时
    @Deprecated
    public static void show() {

    }
}

interface I {
    void p();
}

class A implements I {
    @Override
    // 这是JDK6 特性
    public void p() {
    }
}

class B extends A {
    @Override
    // 使用override 通知编译器，该方法是一个方法覆盖
    // 如果该方法 不构成 方法覆盖，编译器就会报错
    public void p() {
    }
}
Annotation 其实就是代码里的特殊标记, 它用于替代配置文件！！
* 注解不但可以通知编译器，在运行时通知信息给 JVM虚拟机

注解典型应用：在一个类上面使用注解（配置信息），在程序中通过反射技术 获得配置注解信息 ---- 充当配置文件

已经有配置文件技术 xml、properties ，为什么还需要注解 ？？
随着企业端软件应用越来越复杂，配置文件内容越来越多，导致上万行配置文件（配置文件过大，可读性会变得很差） ---- 反射案例：办晚会
* 引入注解目的：解决程序配置可读性问题 ，注解相当于代码中配置文件

注解程序开发流程
1、编写注解类
使用@interface 定义
所有注解类都默认继承 java.lang.annotation.Annotation 接口
注解支持类型：八种基本数据类型和String、Enum、Class、Annotation以及以上类型的数组）
如果注解属性提供默认值 ，使用注解是 不设置新的值
如果注解只有一个value 属性，使用注解 省略value=
public class AnnotationTest2 {

}

// 使用元注解修改 自定义注解
@interface MyAnnotation2 {
    String[] value();// 只有一个value 属性
}

// 这就是一个注解
@interface MyAnnotation {
    // 定义注解属性，和定义接口方法类似
    // 格式：返回值、属性名() 默认值
    int id(); // 这里id 是注解的 属性

    String name(); // 默认 required

    Class c() default MyAnnotation.class;

    // 这里Date 不属于 8种基本类型 String enum Class Annotation --- 报错
    // Date date();
}

@MyAnnotation(id = 0, name = "")
// 因为只有一个value 属性 省略 value=
@MyAnnotation2( { "aaa", "bbb" })
class MyAnnotationBean {

}

2、在一个类 应用注解类
3、通过反射技术获得注解信息
通过java.lang.reflect.AnnotatedElement 在程序运行时 获得注解信息

元注解：修饰注解的注解
@Retention 声明注解存活生命周期 --Source Class Runtime --- 开发中主要使用Runtime
@Target 声明注解可以修饰对象类型 ---- FIELD 、TYPE、METHOD
@Documented 注解可以被 生成API文档
@Inherited 注解在使用时，可以被子类继承
/**
 * 元注解的使用
 *
 * @author seawind
 *
 */
@Annotation1(name = "abc")
public class AnnotationTest3 {
    @Annotation1(name = "abc")
    int a;

    @Annotation1(name = "abc")
    public void p() {

    }
}

// 因为父类使用@Inherited 注解，所以子类自动继承该注解
// @Annotation1(name = "abc")
class AnnotationTest3_2 extends AnnotationTest3 {

}

// 使用@Retention 声明注解声明周期
@Retention(RetentionPolicy.RUNTIME)
// RetentionPolicy.RUNTIME 运行时可见
// RetentionPolicy.CLASS 在字节码阶段仍然可见 --- 运行时丢失
// RetentionPolicy.SOURCE 在源码阶段可见 ---- 给编译器使用
@Target(value = { ElementType.TYPE, ElementType.FIELD, ElementType.METHOD })
// Target修饰注解可以应用目标类型
// Type 该注解可以用于修饰一个类 、接口、枚举
// FIELD 该注解可以修饰成员变量
@Documented
// 该注解的信息 在AnnotationTest3 生成API文档 时 存在
@Inherited
// 如果A类使用该注解，B类继承A类，B类自动继承该注解
@interface Annotation1 {
    String name();
}


注解案例 ： 在运行阶段，通过注解充当配置文件，利用反射技术获得注解中信息
银行转账 ： 最大一次只能汇款XXX钱 （转账金额大小限制）

读取注解信息
步骤一：获得注解修饰反射对象 Class Field Method ---- 这些所有反射对象 都实现了 AnnotatedElement接口
步骤二：通过 AnnotatedElement 接口 boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)  判断目标注解是否存在
步骤三：通过 AnnotatedElement 接口 getAnnotation(Class<T> annotationClass)  获得目标注解
@Retention(RetentionPolicy.RUNTIME)
// 运行可见
@Target(ElementType.METHOD)//必须得写这句
// 修饰类
public @interface BankProperties {
    double max();
}
/**
 * 银行账户
 *
 * @author seawind
 *
 */
public class BankAccount {

    // 账户余额
    private double amount;

    public BankAccount(double amount) {
        this.amount = amount;
    }

    @BankProperties(max = 5000)
    public void transfer(double money) throws SecurityException,
            NoSuchMethodException {
        if (money > amount) {
            throw new RuntimeException("余额不足！");
        }
        // 限制转账金额
        // 方式一 读取配置文件
        // String maxStr = ResourceBundle.getBundle("bank").getString("max");
        // double max = Double.parseDouble(maxStr);
        // if (money > max) {
        // throw new RuntimeException("一次转账最大允许 " + max + "金额，您的转账额度超出了最大额度！");
        // }

        // 方式二 使用注解充当配置文件
        // 读取注解中信息 AnnotatedElement
        // 获得注解修饰反射对象
        Class c = BankAccount.class;
        Method m = c.getMethod("transfer", double.class);
        // 判断目标注解是否存在
        boolean isExist = m.isAnnotationPresent(BankProperties.class);
        if (isExist) {// 注解存在
            // 获得目标注解 --- 返回值可以强制转换为目标注解
            BankProperties bankProperties = (BankProperties) m
                    .getAnnotation(BankProperties.class);
            double max = bankProperties.max();// 获得max 属性
            if (money > max) {
                throw new RuntimeException("一次转账最大允许 " + max
                        + "金额，您的转账额度超出了最大额度！");
            }
        }

        System.out.println("该账户转出金额 :" + money);
        amount -= money;
        System.out.println("余额：" + amount);
    }
}

Servlet3.0 新特性 ----- 对于web 开发很有用的 ---- JavaEE6 最新开发工具
1、web.xml 关于 Servlet 、Filter、Listener 通过注解进行配置
2、服务器异步处理机制
3、集成文件上传API

安装eclipse3.7 和 tomcat7.0
启动Eclipse 版本必须和 JDK版本 位数匹配
启动错误 eclipse.ini -Xmx512m 尝试 修改256 或者 128

在Eclipse集成tomcat 编写web工程
1、创建Dynamic web project --- 配置target runtime 运行环境 tomcat
* eclipse目录默认 没有WebRoot 目录 --- 有WebContent
2、eclipse和my eclipse发布方式不同
* myeclipse 将目录复制tomcat/webapps
* eclipse 内部有tomcat插件，将web目录复制插件目录/webapps

* 自动生成Servers工程目录  --- 保存tomcat启动需要配置文件

1、3.0 web 工程没有web.xml
@WebServlet("/hello")
@WebFilter("/hello")
@WebListener
* 当你配置欢迎页面、错误页面 编写web.xml
* metadata-complete  web-app元素的属性 设置为true 将不支持注解技
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    metadata-complete="false"
    version="3.0"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" >
</web-app>
2、异步处理支持
运行服务器端对Response 用多个线程统计信息响应生成
* 作用 改善用户体验
@WebServlet(value="/hello2",asyncSupported=true)//必须写上asyncSupported=true否则报异常
public class HelloServlet2 extends HttpServlet {
    private static final long serialVersionUID = 1L;
      
    /**
     * @see HttpServlet#HttpServlet()
     */
    public HelloServlet2() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
       
        response.getWriter().println("start servlet ...<br/>");
        // 模拟用户注册：将数据保存到数据库，发送激活邮件
        response.getWriter().println("regist success... <br/>");
        // 因为将用户数据保存到数据库后，发邮件是不是很复杂，很浪费时间
        // 启动一个单独线程发送邮件，先将响应会送给客户端，等发送邮件成功后，再提升用户激活邮件已经发送
        AsyncContext asyncContext = request.startAsync();
        asyncContext.addListener(new AsyncListener() {
           
            @Override
            public void onTimeout(AsyncEvent arg0) throws IOException {
                // TODO Auto-generated method stub
               
            }
           
            @Override
            public void onStartAsync(AsyncEvent arg0) throws IOException {
                // TODO Auto-generated method stub
               
            }
           
            @Override
            public void onError(AsyncEvent arg0) throws IOException {
                // TODO Auto-generated method stub
               
            }
           
            @Override
            public void onComplete(AsyncEvent arg0) throws IOException {
                System.out.println("servlet 完成");
            }
        });
        new Thread(new Exccutor(asyncContext)).start();
       
        response.getWriter().println("end servlet...<br/>");
        response.getWriter().flush();
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

    // 异步发送邮件程序
public class Exccutor implements Runnable {

    private AsyncContext asyncContext;

    public Exccutor(AsyncContext asyncContext) {
        this.asyncContext = asyncContext;
    }

    @Override
    public void run() {
        // 模拟发送邮件
        try {
            Thread.sleep(5000);// 发邮件需要时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            asyncContext.getResponse().getWriter().print("active mail has been send!");
            asyncContext.getResponse().getWriter().flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
       
    }

}
3、内部提供一套API 完成文件上传
编写文件上传form 表单
在服务器端Servlet 中 @MultipartConfig
* getParameter位于getPart操作之前 --- 必须先处理普通form域，再处理上传域
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.Part;


/**
 * Servlet implementation class UploadServlet
 */
@WebServlet("/upload")
@MultipartConfig//必须写
// 写注解 通知服务器form 是一个文件上传表单
public class UploadServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
      
    /**
     * @see HttpServlet#HttpServlet()
     */
    public UploadServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        // 文件上传逻辑
        // 获得用户名
        String username = request.getParameter("username");
        System.out.println(username);
        // 获得上传文件内容
        Part part = request.getPart("upload");
        // 获得上传文件名 解析请求头中 Content-Dispostion
        String filename = getFileName(part);
       
        // 将文件写入c盘
        part.write("c:\\"+filename);
       
       
    }
   
    public String getFileName(Part part) {
        String filename = part.getHeader("content-disposition");
        filename = filename.substring(filename.indexOf("filename=")+10,filename.length()-1);
        int index = filename.lastIndexOf("\\");
        if(index != -1){
            filename = filename.substring(index+1);
        }
        return filename;
    }
    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}


动态代理价值： 当.class文件 被类加载器加载 到内存 形成Class对象，所有程序访问都是针对Class对象 ，动态代理技术可以根据Class对象的实现接口，在内存中虚拟构造一个对象，该对象成为代理对象，访问真实对象的所有API的过程中 都将通过代理对象去访问 。
* 拦截对真实对象的访问 修改访问参数、拦截访问请求
* Java Spring 内部拦截器技术 -- 使用动态代理

动态代理案例
1、编写真实业务对象
2、使用动态代理，必须为真实对象提供一个接口
3、使用Proxy的newInstance 根据真实业务对象，创建代理对象
4. 根据代理对象取间接访问真实对象
5、拦截真实访问后，阻止对目标访问、修改参数、修改返回值
public class Liudehua implements Singable {
    public void sing(double money) {
        System.out.println("出场费：" + money);
        System.out.println("德华演唱歌曲");
    }

    @Override
    public void dance(double money) {
        System.out.println("出场费：" + money);
        System.out.println("德华跳舞了！");
    }
}
public class MainApp {
    public static void main(String[] args) {
        final Liudehua liudehua = new Liudehua();
        // 根据真实业务对象创建代理对象
        Singable proxy = (Singable) Proxy.newProxyInstance(liudehua.getClass()
                .getClassLoader(), liudehua.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    /*
                     * proxy 代理对象本身，method 当前执行方法，args 方法真实参数
                     */
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {
                        System.out.println("被代理了");
                        // 拦截后，修改参数 阻止
                        if (method.getName().equals("sing")) {
                            double money = (Double) args[0];
                            if (money < 5000) {
                                throw new RuntimeException("免谈");
                            }
                            money -= 20000; // 取走20000
                            method.invoke(liudehua, money);
                        }
                        if (method.getName().equals("dance")) {
                            double money = (Double) args[0];
                            if (money < 100000) {
                                throw new RuntimeException("免谈");
                            }
                            money -= 30000; // 取走30000
                            method.invoke(liudehua, money);
                        }
                        return null;
                    }
                });

        // 通过代理对象 访问 真实业务对象 --- 无论执行什么方法 invoke都将执行
        proxy.sing(50000); // invoke 执行 method --- sing args --- 50000
        proxy.dance(100000); // invoke 执行 method --- dance args ---- 100000
    }
}

银行取钱案例 ATM ： 取款手续费用
真实业务对象如果想动态代理，生成代理对象 -------- 实现接口
* 在实际企业开发中，动态代理经常用于加强方法原来逻辑功能  ---- 无需修改原来程序逻辑，就可以实现方法增强
public interface Account {
    // 存钱
    public void saveMoney(double money);

    // 取钱
    public double getMoney(double money);

    // 查询账户余额
    public double queryRestMoney();
}
public class MyAccount implements Account {
    private double amount;

    @Override
    public double getMoney(double money) {
        if (money > amount) {
            // 余额不足
            throw new RuntimeException("余额不足！");
        }
        amount = amount - money;
        return money;
    }

    @Override
    public double queryRestMoney() {
        return amount;
    }

    @Override
    public void saveMoney(double money) {
        amount = amount + money;
    }

}
public class ATM {
    public static void main(String[] args) {
        final Account account = new MyAccount();// 账户对象

        // 使用动态代理，根据真实账户 生成代理对象
        // 代理对象返回类型 必须转换 接口类型
        Account accountProxy = (Account) Proxy.newProxyInstance(account
                .getClass().getClassLoader(), account.getClass()
                .getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // 取款时 收取1%手续费用
                // 需要加强的方法
                // 使用if 判断 该方法 逻辑需要加强
                if (method.getName().equals("getMoney")) {// 用户在取款
                    // 从账户中取出 101% 金额
                    // 获得要取款金额
                    double want_money = (Double) args[0];
                    // 从账户中 取出101% 金额
                    double real_money = want_money * 1.01;
                    // 进行取款
                    double getMoney = (Double) method.invoke(account,
                            real_money);
                    System.out.println("取款:" + want_money + ",收取手续费用 "
                            + (real_money - want_money));

                    return want_money;// 返回要取款金额

                }

                // 不需要加强的方法
                return method.invoke(account, args);
            }
        });

        accountProxy.saveMoney(10000);
        System.out.println("存款 10000");
        double money = accountProxy.getMoney(5000);
        System.out.println("取款 5000");
        double restMoney = accountProxy.queryRestMoney();
        System.out.println("查询余额：" + restMoney);
    }
}

线程和进程区别 ？一个进程是多个线程组成的，进程是操作系统管理内存最小单位，线程使用内存，从进程申请
线程的创建有两种方式：extends Thread、implements Runnable接口
* 获得当前线程的名字 Thread.currentThread().getName();
* 优先使用Runnable 接口 ---- 因为java单继承，如果继承Thread 就不能继承其他类

线程的四种状态：创建(new Thread().start())、执行状态 (线程run方法正在运行)、阻塞状态(run方法在执行一段时间后暂停执行)、线程死亡(run方法执行结束、发生异常)
* 新建 --- 运行 （获得cpu的使用权）
* 运行 --- 阻塞 （Thread.sleep join 使用同步锁 wait IO读写、网络传输）
* 阻塞 --- 运行  结束阻塞，重新获得cpu使用权

sleep 使当前线程睡眠一段时间，睡眠过程中，不释放锁资源
join 等待目标线程执行结束后，其他线程才能继续执行
同步锁，当运行一个代码块，使用同步锁机制，一个线程已经将代码块锁定，另一个线程无法进入代码块 ---- 执行等待锁
wait 当你获得一个同步锁后，选择在锁上面监视器进行等待，等待必须由别人进行 唤醒 notify  notifyAll

锁：保证一段程序同一时间只能由一个线程进行执行 ---- 阻止两个线程同时执行一段代码
* java中每个对象都可以作为锁 ----- 锁的本质，锁定一块内存地址
public class MyThread2 {
    public static void main(String[] args) {
        Object lock = new Object();

        ThreadA a = new ThreadA(lock);
        new Thread(a).start();

        ThreadB b = new ThreadB(lock);
        new Thread(b).start();

        // 保证顺序不乱 --- 加锁 锁定同一个内存
    }
}

class ThreadA implements Runnable {

    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

class ThreadB implements Runnable {

    private Object lock;

    public ThreadB(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

* 特殊锁 锁定方法
public static synchronized void a() {} ---- 锁定 类的Class对象
public synchronized void b() {}  --- 锁定this 对象
同步锁案例 ： 售票系统 模拟火车站多个售票窗口同时售票  ---- 确保同一个时间 只能有一个窗口打票
public class SaleTicketSystem {
    public static void main(String[] args) {
        TicketSystem system = new TicketSystem();// 票源唯一
        for (int i = 0; i < 5; i++) {// 模拟5个窗口同时卖票
            SaleTicket saleTicket = new SaleTicket(system);
            new Thread(saleTicket).start();
        }
    }
}

// 票源
class TicketSystem {
    private int totalTickets = 100; // 总票数
    private int hasSaleTickets = 0; // 已经售票编号

    // 添加同步后，同一时间只能有一个窗口卖票
    public synchronized void saleTicket() {
        if (totalTickets <= 0) {
            throw new RuntimeException("票已经卖完");
        }
        // 卖掉一张票
        hasSaleTickets++;
        System.out.println("打印一张票！" + hasSaleTickets);
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 总票数 -1
        totalTickets--;
        System.out.println("剩余票数：" + totalTickets);
    }

}
//售票
class SaleTicket implements Runnable {

    private TicketSystem ticketSystem;

    public SaleTicket(TicketSystem ticketSystem) {
        this.ticketSystem = ticketSystem;
    }

    @Override
    public void run() {
        while (true) {
            try {
                ticketSystem.saleTicket();
            } catch (RuntimeException e) {
                break;
            }
        }
    }



死锁原因：互相等待 ------ 同步代码块嵌套
* 尽量同步代码块不要嵌套
public class DeadLockTest {
    public static void main(String[] args) {
        Object pen = new Object();// 笔
        Object note = new Object(); // 本

        new Thread(new AThread(pen, note)).start();
        new Thread(new BThread(pen, note)).start();
    }
}

class AThread implements Runnable {

    private Object pen;
    private Object note;

    public AThread(Object pen, Object note) {
        this.pen = pen;
        this.note = note;
    }

    @Override
    public void run() {
        // 先获得笔 --- 再获得本
        synchronized (pen) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (note) {
                System.out.println("A 写字");
            }
        }
    }
}

class BThread implements Runnable {

    private Object pen;
    private Object note;

    public BThread(Object pen, Object note) {
        this.pen = pen;
        this.note = note;
    }

    @Override
    public void run() {
        // 先获得 本 --- 再获得笔
        synchronized (note) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (pen) {
                System.out.println("B 写字");
            }
        }
    }
}

锁监视器操作 ----- java中所有对象都可以作为锁，java 中 Object类 提供 wait notify notifyAll
wait ：当前线程 在锁对象的监视器上进行等待
notify ： 唤醒 一个 在 指定锁对象的监视器上等待的线程
notifyAll : 唤醒所有在指定 锁对象的监视器上等待的线程
* 线程通信案例 （当两个线程协同完成某个任务 ）---- 生产者消费者模型

生产者消费者场景 ：一个生产者、一个消费者，生产者生产一个面包，通知消费者来吃，消费者吃完了，通知生产者生产
* 生产者发现面包还没吃 需要等待
* 消费者发现面包已经吃了 需要等待
/**
 * 生产者 消费者案例
 *
 * @author seawind
 *
 */
public class ProducerConsumerTest {
    public static void main(String[] args) {
        CakeHouse cakeHouse = new CakeHouse();
        new Thread(new Producer(cakeHouse)).start();
        new Thread(new Consumer(cakeHouse)).start();
    }
}

// 生产者
class Producer implements Runnable {

    private CakeHouse cakeHouse;

    public Producer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        // 生产100个蛋糕
        for (int i = 0; i < 100; i++) {
            cakeHouse.put();
        }
    }

}

// 消费者
class Consumer implements Runnable {
    private CakeHouse cakeHouse;

    public Consumer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            cakeHouse.take();
        }
    }

}

class CakeHouse {
    // 蛋糕房 蛋糕窗口
    private List<Object> list = new LinkedList<Object>();
    private int index;

    // 必须先同步，才能使用锁监视器
    public synchronized void put() {
        while (!list.isEmpty()) {
            // 已经有蛋糕
            try {
                this.wait(); // 调用wait的对象 就是锁定对象
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 生产蛋糕
        list.add(new Object());
        index++;
        System.out.println("生产者 生产蛋糕 " + index);

        // 通知消费者 快去吃
        this.notify();
    }

    public synchronized void take() {
        while (list.isEmpty()) {
            // 没蛋糕
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 吃掉蛋糕
        list.remove(0);
        System.out.println("消费者消费蛋糕 " + index);

        // 通知生产者生产
        this.notify();
    }
}

JDK5.0 之后提供两个接口 Lock 和 Condition ，简化同步和锁编程
java.util.concurrent.locks.Lock  ---- 取代 synchronized
java.util.concurrent.locks.Condition  ---- 取代 wait notify
* 在同一个锁上面 建立多个监视器
public class SaleTicketSystem {
    public static void main(String[] args) {
        TicketSystem system = new TicketSystem();// 票源唯一
        for (int i = 0; i < 5; i++) {// 模拟5个窗口同时卖票
            SaleTicket saleTicket = new SaleTicket(system);
            new Thread(saleTicket).start();
        }
    }
}

// 票源
class TicketSystem {
    private int totalTickets = 100; // 总票数
    private int hasSaleTickets = 0; // 已经售票编号
    private Lock lock = new ReentrantLock();

    // 添加同步后，同一时间只能有一个窗口卖票
    public void saleTicket() {
        // 加锁
        lock.lock();

        if (totalTickets <= 0) {
            throw new RuntimeException("票已经卖完");
        }
        // 卖掉一张票
        hasSaleTickets++;
        System.out.println("打印一张票！" + hasSaleTickets);
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 总票数 -1
        totalTickets--;
        System.out.println("剩余票数：" + totalTickets);

        // 解锁
        lock.unlock();
    }

}

class SaleTicket implements Runnable {

    private TicketSystem ticketSystem;

    public SaleTicket(TicketSystem ticketSystem) {
        this.ticketSystem = ticketSystem;
    }

    @Override
    public void run() {
        while (true) {
            try {
                ticketSystem.saleTicket();
            } catch (RuntimeException e) {
                break;
            }
        }
    }

}
/**
 * 生产者 消费者案例
 *
 * @author seawind
 *
 */
public class ProducerConsumerTest {
    public static void main(String[] args) {
        CakeHouse cakeHouse = new CakeHouse();
        new Thread(new Producer(cakeHouse)).start();
        new Thread(new Consumer(cakeHouse)).start();
    }
}

// 生产者
class Producer implements Runnable {

    private CakeHouse cakeHouse;

    public Producer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        // 生产100个蛋糕
        for (int i = 0; i < 100; i++) {
            cakeHouse.put();
        }
    }

}

// 消费者
class Consumer implements Runnable {
    private CakeHouse cakeHouse;

    public Consumer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            cakeHouse.take();
        }
    }

}

class CakeHouse {
    // 蛋糕房 蛋糕窗口
    private List<Object> list = new LinkedList<Object>();
    private int index;
    private Lock lock = new ReentrantLock();
    // 生产者专用监视器
    private Condition producerCondition = lock.newCondition();
    // 消费者专用监视器
    private Condition consumerCondition = lock.newCondition();

    public void put() {
        lock.lock();
        while (!list.isEmpty()) {
            // 已经有蛋糕
            try {
                producerCondition.await(); // 在生产者监视器上等
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 生产蛋糕
        list.add(new Object());
        index++;
        System.out.println("生产者 生产蛋糕 " + index);

        // 通知消费者 快去吃
        consumerCondition.signal();

        lock.unlock();
    }

    public void take() {
        lock.lock();
        while (list.isEmpty()) {
            // 没蛋糕
            try {
                consumerCondition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 吃掉蛋糕
        list.remove(0);
        System.out.println("消费者消费蛋糕 " + index);

        // 通知生产者生产
        producerCondition.signal();

        lock.unlock();
    }
}
java.util.concurrent 包 和 子包 ---- ArrayBlockingQueue<E> CopyOnWriteArrayList<E> LinkedBlockingQueue<E> 

线程池技术 Excutors
为什么用线程池，线程创建、关闭释放资源 ---- 消耗程序性能
一次创建多个线程，做任务，随机获得一个线程，完成任务，将线程归还线程池

newFixedThreadPool(int nThreads) 固定线程数量线程池
newCachedThreadPool()  返回根据程序需要自动扩充大小 线程池 ----- 最常用
newSingleThreadExecutor()  返回单线程处理程序

shutdown与shutdownNow的比较
shutdown 完成当前线程池中所有任务 再关闭
shutdownNow 会对当前线程池中所有线程，调用interrupt 尝试打断当前线程，如果无法打断，会执行结束
public class ExcutorsTest {
    // java中编写程序测试多线程，一定不能用 junit --- System.exit
    public static void main(String[] args) {
        // 创建线程池
        // 创建固定数量为3 线程池
        // ExecutorService service = Executors.newFixedThreadPool(5);
        // 创建 自增扩充大小 线程池
        ExecutorService service = Executors.newCachedThreadPool();

        // 单一线程对象
        // ExecutorService service = Executors.newSingleThreadExecutor();

        // 开启十个线程 分别输出
        for (int i = 0; i < 10; i++) {
            service.execute(new MyExcutor());
        }

        // 关闭连接池
        service.shutdown();// 当之前任务都结束后，尝试关闭连接池
        // service.shutdownNow();// 尝试马上关闭连接池，但是不一定能关闭
        // interrupt
    }
}

class MyExcutor implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
------------------------------------------------------------------------------------------------------------------
OSI 七层体系结构：　应用层、表示层、会话层、传输层、网络层、数据链路层、物理层　
*协议层次越高，越容易让人理解， 层次越低，数据越接近0 1
TCP/IP 四层 ： 应用层、传输层、网际层、网络接口层

应用层、传输层
应用层：HTTP SMTP POP3 FTP TELNET
传输层：TCP（不允许丢包 三次握手） UDP（广播 允许丢包）

三次握手：
A 向 B 发送一个消息：能听到我说话吗
B 回复 A 消息：我能听到，你能听到我说话吗
A 回复 B ：我能听到

TCP发送数据没有收到对方回应，选择重新发送 ---- 时间限制 超时

Socket 两台计算机之间一个连接 ---- 两台计算机可以通信

使用socket建立双方连接 -----传输协议需要自己编写 面向底层协议

socket 编写程序 可以模拟服务器，可以模拟客户端
服务器如何编写

* 使用socket进行通信过程中，如果调用in.readLine 但是对方没有写 ---- 程序一直等待 、out.print向对方发送信息 没有阻塞
/**
 * 模拟服务器
 *
 * @author seawind
 *
 */
public class Server {
    public static void main(String[] args) throws IOException {
        // 步骤一 创建ServerSocket 对象
        ServerSocket serverSocket = new ServerSocket(9000);
        // 连接服务器需要 ip 和 端口

        // 步骤二 等待客户端来连接
        Socket socket = serverSocket.accept(); // socket代表一个连接

        // 步骤三 需要获得流
        PrintWriter out = new PrintWriter(socket.getOutputStream());
        BufferedReader in = new BufferedReader(new InputStreamReader(socket
                .getInputStream()));

        // 收取对方信息 用 in
        // 发送给对方信息 用 out

        out.println("Hello !");// 输出信息 因为用字符流 ，所以flush
        out.flush();

        System.out.println(in.readLine());
    }
}
/**
 * 客户端
 *
 * @author seawind
 *
 */
public class Client {
    public static void main(String[] args) throws UnknownHostException,
            IOException {
        // 步骤一 连接服务器
        Socket socket = new Socket("localhost", 9000);

        // 步骤二 获得流
        PrintWriter out = new PrintWriter(socket.getOutputStream());
        BufferedReader in = new BufferedReader(new InputStreamReader(socket
                .getInputStream()));

        // 通过in 获得信息
        System.out.println(in.readLine());

        out.println("你好服务器！");
        out.flush();
    }
}


socket 案例 ----- 模拟tomcat服务器

/**
 * 模拟tomcat server
 *
 * @author seawind
 *
 */
public class TomcatServer {
    public static void main(String[] args) throws IOException {
        // 步骤一
        ServerSocket serverSocket = new ServerSocket(9000);

        // 创建线程池
        ExecutorService executorService = Executors.newCachedThreadPool();

        while (true) {
            // 步骤二 获得与客户端连接
            Socket socket = serverSocket.accept();
            DealResponse dealResponse = new DealResponse(socket);
            // 将处理任务 加入线程池
            executorService.execute(dealResponse);

        }
    }

    static class DealResponse implements Runnable {
        private Socket socket;

        public DealResponse(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                // 步骤三 流
                OutputStream bout = new BufferedOutputStream(socket
                        .getOutputStream());
                // PrintWriter out = new PrintWriter(socket.getOutputStream());
                BufferedReader in = new BufferedReader(new InputStreamReader(
                        socket.getInputStream()));

                // 浏览器连接服务器 发送HTTP请求
                String requestline = in.readLine();// 获得请求行

                // 解析资源路径
                String path = parse(requestline);
                System.out.println(path);

                // 判断目标文件是否存在
                File file = new File("webroot" + path);
                // 判断服务器上面 有没有客户访问文件
                if (file.exists()) {
                    // 回写HTTP协议格式
                    bout.write("HTTP/1.1 200 OK\r\n".getBytes());

                    // 根据文件扩展名得到文件格式

                    bout
                            .write(("Content-Type:" + getType(file.getName()) + "\r\n")
                                    .getBytes()); // 不同文件类型是不同的
                    bout.write(("Content-Length:" + file.length() + "\r\n\r\n")
                            .getBytes());

                    // 存在
                    InputStream fis = new BufferedInputStream(
                            new FileInputStream(file));
                    int temp;
                    while ((temp = fis.read()) != -1) {
                        bout.write(temp);
                    }
                    bout.flush();
                    bout.close();
                    fis.close();
                    System.out.println("文件找到了");
                } else {
                    // 不存在
                    bout.write("file not found".getBytes());
                    bout.flush();
                    System.out.println("文件找不到！");
                    bout.close();
                }

                // 断开socket连接
                in.close();
                socket.close();
            } catch (FileNotFoundException e) {
                // e.printStackTrace();
            } catch (IOException e) {
                // e.printStackTrace();
            }
        }
    }

    private static String getType(String name) {
        // 获得扩展名
        String ext = name.substring(name.lastIndexOf(".") + 1);
        String type = ResourceBundle.getBundle("mime").getString(ext);
        return type;
    }

    private static String parse(String requestline) {
        return requestline.split(" ")[1];
    }

}

---------------------------------------------------------------------------------------

注解的使用 ---- 定义注解，利用反射解析注解内容 （案例：银行转账最大金额）
Servlet3.0 注解开发Servlet、异步技术、文件上传
动态代理 （案例：德华案例、银行取款 收取手续费用）
多线程：两种线程创建方式、四种状态、同步和锁、死锁、wait和notify （案例：卖票、生产蛋糕） ---- 使用JDK5 Lock和Condition 重写

socket编程 服务器怎么写 客户端怎么写
* 实际socket案例 按照协议发送内容 模拟tomcat 服务器 遵循HTTP协议








































































































K5.0新特性（泛型、枚举、for/in、可变参数、自动装箱拆箱、静态导入） + 反射 API（Class、Construtctor 、Field、Method ）
字符串格式化 StringFormat、System.out.printf
注解技术
线程并发库

Java基础加强第二天 ：上午：注解技术使用 @override ----- Servlet3.0 新特性 （之前课程中2.5 特性） 、动态代理技术（方法增强三种方式）
下午：复习线程基础知识、多线程编写案例 、Java5 提供线程并发库 线程池 、Socket网络编程（自定义服务器案例 tomcat）

Java Annotation 注解技术 是java5.0 新特性 （如果编译环境是java1.4 之前版本 无法对注解进行编译）

JDK官方提供了三个注解
@Override: 限定重写父类方法, 该注解只能用于方法 ------ 编译时检查，不构成覆盖 报错
* JDK5.0 override注解只能用于方法覆盖 JDK6.0 该注解可以用于接口的方法实现
@Deprecated: 用于表示某个程序元素(类, 方法等)已过时 ----- 在编译器进行编译时 报出一个警告
* 为什么会有过时方法： 提供了新的方法取代 之前方法、发现某个方法存在安全隐患，不建议用户再使用
@SuppressWarnings: 抑制编译器警告.  ---- 通知编译器在编译时 不要报出警告信息
* 使用 all 忽略所有警告信息
@SuppressWarnings("all")
    // 抑制警告信息 类型
    public static void main(String[] args) {
        int a;

        List list = new ArrayList();

        Thread t = new Thread();
        t.start();
        t.stop();// 删除线，因为stop 方法已经过时

        show();
    }

    // 通过deprecated 使 show 方法过时
    @Deprecated
    public static void show() {

    }
}

interface I {
    void p();
}

class A implements I {
    @Override
    // 这是JDK6 特性
    public void p() {
    }
}

class B extends A {
    @Override
    // 使用override 通知编译器，该方法是一个方法覆盖
    // 如果该方法 不构成 方法覆盖，编译器就会报错
    public void p() {
    }
}
Annotation 其实就是代码里的特殊标记, 它用于替代配置文件！！
* 注解不但可以通知编译器，在运行时通知信息给 JVM虚拟机

注解典型应用：在一个类上面使用注解（配置信息），在程序中通过反射技术 获得配置注解信息 ---- 充当配置文件

已经有配置文件技术 xml、properties ，为什么还需要注解 ？？
随着企业端软件应用越来越复杂，配置文件内容越来越多，导致上万行配置文件（配置文件过大，可读性会变得很差） ---- 反射案例：办晚会
* 引入注解目的：解决程序配置可读性问题 ，注解相当于代码中配置文件

注解程序开发流程
1、编写注解类
使用@interface 定义
所有注解类都默认继承 java.lang.annotation.Annotation 接口
注解支持类型：八种基本数据类型和String、Enum、Class、Annotation以及以上类型的数组）
如果注解属性提供默认值 ，使用注解是 不设置新的值
如果注解只有一个value 属性，使用注解 省略value=
public class AnnotationTest2 {

}

// 使用元注解修改 自定义注解
@interface MyAnnotation2 {
    String[] value();// 只有一个value 属性
}

// 这就是一个注解
@interface MyAnnotation {
    // 定义注解属性，和定义接口方法类似
    // 格式：返回值、属性名() 默认值
    int id(); // 这里id 是注解的 属性

    String name(); // 默认 required

    Class c() default MyAnnotation.class;

    // 这里Date 不属于 8种基本类型 String enum Class Annotation --- 报错
    // Date date();
}

@MyAnnotation(id = 0, name = "")
// 因为只有一个value 属性 省略 value=
@MyAnnotation2( { "aaa", "bbb" })
class MyAnnotationBean {

}

2、在一个类 应用注解类
3、通过反射技术获得注解信息
通过java.lang.reflect.AnnotatedElement 在程序运行时 获得注解信息

元注解：修饰注解的注解
@Retention 声明注解存活生命周期 --Source Class Runtime --- 开发中主要使用Runtime
@Target 声明注解可以修饰对象类型 ---- FIELD 、TYPE、METHOD
@Documented 注解可以被 生成API文档
@Inherited 注解在使用时，可以被子类继承
/**
 * 元注解的使用
 *
 * @author seawind
 *
 */
@Annotation1(name = "abc")
public class AnnotationTest3 {
    @Annotation1(name = "abc")
    int a;

    @Annotation1(name = "abc")
    public void p() {

    }
}

// 因为父类使用@Inherited 注解，所以子类自动继承该注解
// @Annotation1(name = "abc")
class AnnotationTest3_2 extends AnnotationTest3 {

}

// 使用@Retention 声明注解声明周期
@Retention(RetentionPolicy.RUNTIME)
// RetentionPolicy.RUNTIME 运行时可见
// RetentionPolicy.CLASS 在字节码阶段仍然可见 --- 运行时丢失
// RetentionPolicy.SOURCE 在源码阶段可见 ---- 给编译器使用
@Target(value = { ElementType.TYPE, ElementType.FIELD, ElementType.METHOD })
// Target修饰注解可以应用目标类型
// Type 该注解可以用于修饰一个类 、接口、枚举
// FIELD 该注解可以修饰成员变量
@Documented
// 该注解的信息 在AnnotationTest3 生成API文档 时 存在
@Inherited
// 如果A类使用该注解，B类继承A类，B类自动继承该注解
@interface Annotation1 {
    String name();
}


注解案例 ： 在运行阶段，通过注解充当配置文件，利用反射技术获得注解中信息
银行转账 ： 最大一次只能汇款XXX钱 （转账金额大小限制）

读取注解信息
步骤一：获得注解修饰反射对象 Class Field Method ---- 这些所有反射对象 都实现了 AnnotatedElement接口
步骤二：通过 AnnotatedElement 接口 boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)  判断目标注解是否存在
步骤三：通过 AnnotatedElement 接口 getAnnotation(Class<T> annotationClass)  获得目标注解
@Retention(RetentionPolicy.RUNTIME)
// 运行可见
@Target(ElementType.METHOD)//必须得写这句
// 修饰类
public @interface BankProperties {
    double max();
}
/**
 * 银行账户
 *
 * @author seawind
 *
 */
public class BankAccount {

    // 账户余额
    private double amount;

    public BankAccount(double amount) {
        this.amount = amount;
    }

    @BankProperties(max = 5000)
    public void transfer(double money) throws SecurityException,
            NoSuchMethodException {
        if (money > amount) {
            throw new RuntimeException("余额不足！");
        }
        // 限制转账金额
        // 方式一 读取配置文件
        // String maxStr = ResourceBundle.getBundle("bank").getString("max");
        // double max = Double.parseDouble(maxStr);
        // if (money > max) {
        // throw new RuntimeException("一次转账最大允许 " + max + "金额，您的转账额度超出了最大额度！");
        // }

        // 方式二 使用注解充当配置文件
        // 读取注解中信息 AnnotatedElement
        // 获得注解修饰反射对象
        Class c = BankAccount.class;
        Method m = c.getMethod("transfer", double.class);
        // 判断目标注解是否存在
        boolean isExist = m.isAnnotationPresent(BankProperties.class);
        if (isExist) {// 注解存在
            // 获得目标注解 --- 返回值可以强制转换为目标注解
            BankProperties bankProperties = (BankProperties) m
                    .getAnnotation(BankProperties.class);
            double max = bankProperties.max();// 获得max 属性
            if (money > max) {
                throw new RuntimeException("一次转账最大允许 " + max
                        + "金额，您的转账额度超出了最大额度！");
            }
        }

        System.out.println("该账户转出金额 :" + money);
        amount -= money;
        System.out.println("余额：" + amount);
    }
}

Servlet3.0 新特性 ----- 对于web 开发很有用的 ---- JavaEE6 最新开发工具
1、web.xml 关于 Servlet 、Filter、Listener 通过注解进行配置
2、服务器异步处理机制
3、集成文件上传API

安装eclipse3.7 和 tomcat7.0
启动Eclipse 版本必须和 JDK版本 位数匹配
启动错误 eclipse.ini -Xmx512m 尝试 修改256 或者 128

在Eclipse集成tomcat 编写web工程
1、创建Dynamic web project --- 配置target runtime 运行环境 tomcat
* eclipse目录默认 没有WebRoot 目录 --- 有WebContent
2、eclipse和my eclipse发布方式不同
* myeclipse 将目录复制tomcat/webapps
* eclipse 内部有tomcat插件，将web目录复制插件目录/webapps

* 自动生成Servers工程目录  --- 保存tomcat启动需要配置文件

1、3.0 web 工程没有web.xml
@WebServlet("/hello")
@WebFilter("/hello")
@WebListener
* 当你配置欢迎页面、错误页面 编写web.xml
* metadata-complete  web-app元素的属性 设置为true 将不支持注解技
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    metadata-complete="false"
    version="3.0"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" >
</web-app>
2、异步处理支持
运行服务器端对Response 用多个线程统计信息响应生成
* 作用 改善用户体验
@WebServlet(value="/hello2",asyncSupported=true)//必须写上asyncSupported=true否则报异常
public class HelloServlet2 extends HttpServlet {
    private static final long serialVersionUID = 1L;
      
    /**
     * @see HttpServlet#HttpServlet()
     */
    public HelloServlet2() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
       
        response.getWriter().println("start servlet ...<br/>");
        // 模拟用户注册：将数据保存到数据库，发送激活邮件
        response.getWriter().println("regist success... <br/>");
        // 因为将用户数据保存到数据库后，发邮件是不是很复杂，很浪费时间
        // 启动一个单独线程发送邮件，先将响应会送给客户端，等发送邮件成功后，再提升用户激活邮件已经发送
        AsyncContext asyncContext = request.startAsync();
        asyncContext.addListener(new AsyncListener() {
           
            @Override
            public void onTimeout(AsyncEvent arg0) throws IOException {
                // TODO Auto-generated method stub
               
            }
           
            @Override
            public void onStartAsync(AsyncEvent arg0) throws IOException {
                // TODO Auto-generated method stub
               
            }
           
            @Override
            public void onError(AsyncEvent arg0) throws IOException {
                // TODO Auto-generated method stub
               
            }
           
            @Override
            public void onComplete(AsyncEvent arg0) throws IOException {
                System.out.println("servlet 完成");
            }
        });
        new Thread(new Exccutor(asyncContext)).start();
       
        response.getWriter().println("end servlet...<br/>");
        response.getWriter().flush();
    }

    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // TODO Auto-generated method stub
    }

    // 异步发送邮件程序
public class Exccutor implements Runnable {

    private AsyncContext asyncContext;

    public Exccutor(AsyncContext asyncContext) {
        this.asyncContext = asyncContext;
    }

    @Override
    public void run() {
        // 模拟发送邮件
        try {
            Thread.sleep(5000);// 发邮件需要时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            asyncContext.getResponse().getWriter().print("active mail has been send!");
            asyncContext.getResponse().getWriter().flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
       
    }

}
3、内部提供一套API 完成文件上传
编写文件上传form 表单
在服务器端Servlet 中 @MultipartConfig
* getParameter位于getPart操作之前 --- 必须先处理普通form域，再处理上传域
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.MultipartConfig;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.Part;


/**
 * Servlet implementation class UploadServlet
 */
@WebServlet("/upload")
@MultipartConfig//必须写
// 写注解 通知服务器form 是一个文件上传表单
public class UploadServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
      
    /**
     * @see HttpServlet#HttpServlet()
     */
    public UploadServlet() {
        super();
        // TODO Auto-generated constructor stub
    }

    /**
     * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("utf-8");
        // 文件上传逻辑
        // 获得用户名
        String username = request.getParameter("username");
        System.out.println(username);
        // 获得上传文件内容
        Part part = request.getPart("upload");
        // 获得上传文件名 解析请求头中 Content-Dispostion
        String filename = getFileName(part);
       
        // 将文件写入c盘
        part.write("c:\\"+filename);
       
       
    }
   
    public String getFileName(Part part) {
        String filename = part.getHeader("content-disposition");
        filename = filename.substring(filename.indexOf("filename=")+10,filename.length()-1);
        int index = filename.lastIndexOf("\\");
        if(index != -1){
            filename = filename.substring(index+1);
        }
        return filename;
    }
    /**
     * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
     */
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}


动态代理价值： 当.class文件 被类加载器加载 到内存 形成Class对象，所有程序访问都是针对Class对象 ，动态代理技术可以根据Class对象的实现接口，在内存中虚拟构造一个对象，该对象成为代理对象，访问真实对象的所有API的过程中 都将通过代理对象去访问 。
* 拦截对真实对象的访问 修改访问参数、拦截访问请求
* Java Spring 内部拦截器技术 -- 使用动态代理

动态代理案例
1、编写真实业务对象
2、使用动态代理，必须为真实对象提供一个接口
3、使用Proxy的newInstance 根据真实业务对象，创建代理对象
4. 根据代理对象取间接访问真实对象
5、拦截真实访问后，阻止对目标访问、修改参数、修改返回值
public class Liudehua implements Singable {
    public void sing(double money) {
        System.out.println("出场费：" + money);
        System.out.println("德华演唱歌曲");
    }

    @Override
    public void dance(double money) {
        System.out.println("出场费：" + money);
        System.out.println("德华跳舞了！");
    }
}
public class MainApp {
    public static void main(String[] args) {
        final Liudehua liudehua = new Liudehua();
        // 根据真实业务对象创建代理对象
        Singable proxy = (Singable) Proxy.newProxyInstance(liudehua.getClass()
                .getClassLoader(), liudehua.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    /*
                     * proxy 代理对象本身，method 当前执行方法，args 方法真实参数
                     */
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {
                        System.out.println("被代理了");
                        // 拦截后，修改参数 阻止
                        if (method.getName().equals("sing")) {
                            double money = (Double) args[0];
                            if (money < 5000) {
                                throw new RuntimeException("免谈");
                            }
                            money -= 20000; // 取走20000
                            method.invoke(liudehua, money);
                        }
                        if (method.getName().equals("dance")) {
                            double money = (Double) args[0];
                            if (money < 100000) {
                                throw new RuntimeException("免谈");
                            }
                            money -= 30000; // 取走30000
                            method.invoke(liudehua, money);
                        }
                        return null;
                    }
                });

        // 通过代理对象 访问 真实业务对象 --- 无论执行什么方法 invoke都将执行
        proxy.sing(50000); // invoke 执行 method --- sing args --- 50000
        proxy.dance(100000); // invoke 执行 method --- dance args ---- 100000
    }
}

银行取钱案例 ATM ： 取款手续费用
真实业务对象如果想动态代理，生成代理对象 -------- 实现接口
* 在实际企业开发中，动态代理经常用于加强方法原来逻辑功能  ---- 无需修改原来程序逻辑，就可以实现方法增强
public interface Account {
    // 存钱
    public void saveMoney(double money);

    // 取钱
    public double getMoney(double money);

    // 查询账户余额
    public double queryRestMoney();
}
public class MyAccount implements Account {
    private double amount;

    @Override
    public double getMoney(double money) {
        if (money > amount) {
            // 余额不足
            throw new RuntimeException("余额不足！");
        }
        amount = amount - money;
        return money;
    }

    @Override
    public double queryRestMoney() {
        return amount;
    }

    @Override
    public void saveMoney(double money) {
        amount = amount + money;
    }

}
public class ATM {
    public static void main(String[] args) {
        final Account account = new MyAccount();// 账户对象

        // 使用动态代理，根据真实账户 生成代理对象
        // 代理对象返回类型 必须转换 接口类型
        Account accountProxy = (Account) Proxy.newProxyInstance(account
                .getClass().getClassLoader(), account.getClass()
                .getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                // 取款时 收取1%手续费用
                // 需要加强的方法
                // 使用if 判断 该方法 逻辑需要加强
                if (method.getName().equals("getMoney")) {// 用户在取款
                    // 从账户中取出 101% 金额
                    // 获得要取款金额
                    double want_money = (Double) args[0];
                    // 从账户中 取出101% 金额
                    double real_money = want_money * 1.01;
                    // 进行取款
                    double getMoney = (Double) method.invoke(account,
                            real_money);
                    System.out.println("取款:" + want_money + ",收取手续费用 "
                            + (real_money - want_money));

                    return want_money;// 返回要取款金额

                }

                // 不需要加强的方法
                return method.invoke(account, args);
            }
        });

        accountProxy.saveMoney(10000);
        System.out.println("存款 10000");
        double money = accountProxy.getMoney(5000);
        System.out.println("取款 5000");
        double restMoney = accountProxy.queryRestMoney();
        System.out.println("查询余额：" + restMoney);
    }
}

线程和进程区别 ？一个进程是多个线程组成的，进程是操作系统管理内存最小单位，线程使用内存，从进程申请
线程的创建有两种方式：extends Thread、implements Runnable接口
* 获得当前线程的名字 Thread.currentThread().getName();
* 优先使用Runnable 接口 ---- 因为java单继承，如果继承Thread 就不能继承其他类

线程的四种状态：创建(new Thread().start())、执行状态 (线程run方法正在运行)、阻塞状态(run方法在执行一段时间后暂停执行)、线程死亡(run方法执行结束、发生异常)
* 新建 --- 运行 （获得cpu的使用权）
* 运行 --- 阻塞 （Thread.sleep join 使用同步锁 wait IO读写、网络传输）
* 阻塞 --- 运行  结束阻塞，重新获得cpu使用权

sleep 使当前线程睡眠一段时间，睡眠过程中，不释放锁资源
join 等待目标线程执行结束后，其他线程才能继续执行
同步锁，当运行一个代码块，使用同步锁机制，一个线程已经将代码块锁定，另一个线程无法进入代码块 ---- 执行等待锁
wait 当你获得一个同步锁后，选择在锁上面监视器进行等待，等待必须由别人进行 唤醒 notify  notifyAll

锁：保证一段程序同一时间只能由一个线程进行执行 ---- 阻止两个线程同时执行一段代码
* java中每个对象都可以作为锁 ----- 锁的本质，锁定一块内存地址
public class MyThread2 {
    public static void main(String[] args) {
        Object lock = new Object();

        ThreadA a = new ThreadA(lock);
        new Thread(a).start();

        ThreadB b = new ThreadB(lock);
        new Thread(b).start();

        // 保证顺序不乱 --- 加锁 锁定同一个内存
    }
}

class ThreadA implements Runnable {

    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

class ThreadB implements Runnable {

    private Object lock;

    public ThreadB(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

* 特殊锁 锁定方法
public static synchronized void a() {} ---- 锁定 类的Class对象
public synchronized void b() {}  --- 锁定this 对象
同步锁案例 ： 售票系统 模拟火车站多个售票窗口同时售票  ---- 确保同一个时间 只能有一个窗口打票
public class SaleTicketSystem {
    public static void main(String[] args) {
        TicketSystem system = new TicketSystem();// 票源唯一
        for (int i = 0; i < 5; i++) {// 模拟5个窗口同时卖票
            SaleTicket saleTicket = new SaleTicket(system);
            new Thread(saleTicket).start();
        }
    }
}

// 票源
class TicketSystem {
    private int totalTickets = 100; // 总票数
    private int hasSaleTickets = 0; // 已经售票编号

    // 添加同步后，同一时间只能有一个窗口卖票
    public synchronized void saleTicket() {
        if (totalTickets <= 0) {
            throw new RuntimeException("票已经卖完");
        }
        // 卖掉一张票
        hasSaleTickets++;
        System.out.println("打印一张票！" + hasSaleTickets);
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 总票数 -1
        totalTickets--;
        System.out.println("剩余票数：" + totalTickets);
    }

}
//售票
class SaleTicket implements Runnable {

    private TicketSystem ticketSystem;

    public SaleTicket(TicketSystem ticketSystem) {
        this.ticketSystem = ticketSystem;
    }

    @Override
    public void run() {
        while (true) {
            try {
                ticketSystem.saleTicket();
            } catch (RuntimeException e) {
                break;
            }
        }
    }



死锁原因：互相等待 ------ 同步代码块嵌套
* 尽量同步代码块不要嵌套
public class DeadLockTest {
    public static void main(String[] args) {
        Object pen = new Object();// 笔
        Object note = new Object(); // 本

        new Thread(new AThread(pen, note)).start();
        new Thread(new BThread(pen, note)).start();
    }
}

class AThread implements Runnable {

    private Object pen;
    private Object note;

    public AThread(Object pen, Object note) {
        this.pen = pen;
        this.note = note;
    }

    @Override
    public void run() {
        // 先获得笔 --- 再获得本
        synchronized (pen) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (note) {
                System.out.println("A 写字");
            }
        }
    }
}

class BThread implements Runnable {

    private Object pen;
    private Object note;

    public BThread(Object pen, Object note) {
        this.pen = pen;
        this.note = note;
    }

    @Override
    public void run() {
        // 先获得 本 --- 再获得笔
        synchronized (note) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (pen) {
                System.out.println("B 写字");
            }
        }
    }
}

锁监视器操作 ----- java中所有对象都可以作为锁，java 中 Object类 提供 wait notify notifyAll
wait ：当前线程 在锁对象的监视器上进行等待
notify ： 唤醒 一个 在 指定锁对象的监视器上等待的线程
notifyAll : 唤醒所有在指定 锁对象的监视器上等待的线程
* 线程通信案例 （当两个线程协同完成某个任务 ）---- 生产者消费者模型

生产者消费者场景 ：一个生产者、一个消费者，生产者生产一个面包，通知消费者来吃，消费者吃完了，通知生产者生产
* 生产者发现面包还没吃 需要等待
* 消费者发现面包已经吃了 需要等待
/**
 * 生产者 消费者案例
 *
 * @author seawind
 *
 */
public class ProducerConsumerTest {
    public static void main(String[] args) {
        CakeHouse cakeHouse = new CakeHouse();
        new Thread(new Producer(cakeHouse)).start();
        new Thread(new Consumer(cakeHouse)).start();
    }
}

// 生产者
class Producer implements Runnable {

    private CakeHouse cakeHouse;

    public Producer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        // 生产100个蛋糕
        for (int i = 0; i < 100; i++) {
            cakeHouse.put();
        }
    }

}

// 消费者
class Consumer implements Runnable {
    private CakeHouse cakeHouse;

    public Consumer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            cakeHouse.take();
        }
    }

}

class CakeHouse {
    // 蛋糕房 蛋糕窗口
    private List<Object> list = new LinkedList<Object>();
    private int index;

    // 必须先同步，才能使用锁监视器
    public synchronized void put() {
        while (!list.isEmpty()) {
            // 已经有蛋糕
            try {
                this.wait(); // 调用wait的对象 就是锁定对象
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 生产蛋糕
        list.add(new Object());
        index++;
        System.out.println("生产者 生产蛋糕 " + index);

        // 通知消费者 快去吃
        this.notify();
    }

    public synchronized void take() {
        while (list.isEmpty()) {
            // 没蛋糕
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 吃掉蛋糕
        list.remove(0);
        System.out.println("消费者消费蛋糕 " + index);

        // 通知生产者生产
        this.notify();
    }
}

JDK5.0 之后提供两个接口 Lock 和 Condition ，简化同步和锁编程
java.util.concurrent.locks.Lock  ---- 取代 synchronized
java.util.concurrent.locks.Condition  ---- 取代 wait notify
* 在同一个锁上面 建立多个监视器
public class SaleTicketSystem {
    public static void main(String[] args) {
        TicketSystem system = new TicketSystem();// 票源唯一
        for (int i = 0; i < 5; i++) {// 模拟5个窗口同时卖票
            SaleTicket saleTicket = new SaleTicket(system);
            new Thread(saleTicket).start();
        }
    }
}

// 票源
class TicketSystem {
    private int totalTickets = 100; // 总票数
    private int hasSaleTickets = 0; // 已经售票编号
    private Lock lock = new ReentrantLock();

    // 添加同步后，同一时间只能有一个窗口卖票
    public void saleTicket() {
        // 加锁
        lock.lock();

        if (totalTickets <= 0) {
            throw new RuntimeException("票已经卖完");
        }
        // 卖掉一张票
        hasSaleTickets++;
        System.out.println("打印一张票！" + hasSaleTickets);
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 总票数 -1
        totalTickets--;
        System.out.println("剩余票数：" + totalTickets);

        // 解锁
        lock.unlock();
    }

}

class SaleTicket implements Runnable {

    private TicketSystem ticketSystem;

    public SaleTicket(TicketSystem ticketSystem) {
        this.ticketSystem = ticketSystem;
    }

    @Override
    public void run() {
        while (true) {
            try {
                ticketSystem.saleTicket();
            } catch (RuntimeException e) {
                break;
            }
        }
    }

}
/**
 * 生产者 消费者案例
 *
 * @author seawind
 *
 */
public class ProducerConsumerTest {
    public static void main(String[] args) {
        CakeHouse cakeHouse = new CakeHouse();
        new Thread(new Producer(cakeHouse)).start();
        new Thread(new Consumer(cakeHouse)).start();
    }
}

// 生产者
class Producer implements Runnable {

    private CakeHouse cakeHouse;

    public Producer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        // 生产100个蛋糕
        for (int i = 0; i < 100; i++) {
            cakeHouse.put();
        }
    }

}

// 消费者
class Consumer implements Runnable {
    private CakeHouse cakeHouse;

    public Consumer(CakeHouse cakeHouse) {
        this.cakeHouse = cakeHouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            cakeHouse.take();
        }
    }

}

class CakeHouse {
    // 蛋糕房 蛋糕窗口
    private List<Object> list = new LinkedList<Object>();
    private int index;
    private Lock lock = new ReentrantLock();
    // 生产者专用监视器
    private Condition producerCondition = lock.newCondition();
    // 消费者专用监视器
    private Condition consumerCondition = lock.newCondition();

    public void put() {
        lock.lock();
        while (!list.isEmpty()) {
            // 已经有蛋糕
            try {
                producerCondition.await(); // 在生产者监视器上等
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 生产蛋糕
        list.add(new Object());
        index++;
        System.out.println("生产者 生产蛋糕 " + index);

        // 通知消费者 快去吃
        consumerCondition.signal();

        lock.unlock();
    }

    public void take() {
        lock.lock();
        while (list.isEmpty()) {
            // 没蛋糕
            try {
                consumerCondition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 吃掉蛋糕
        list.remove(0);
        System.out.println("消费者消费蛋糕 " + index);

        // 通知生产者生产
        producerCondition.signal();

        lock.unlock();
    }
}
java.util.concurrent 包 和 子包 ---- ArrayBlockingQueue<E> CopyOnWriteArrayList<E> LinkedBlockingQueue<E> 

线程池技术 Excutors
为什么用线程池，线程创建、关闭释放资源 ---- 消耗程序性能
一次创建多个线程，做任务，随机获得一个线程，完成任务，将线程归还线程池

newFixedThreadPool(int nThreads) 固定线程数量线程池
newCachedThreadPool()  返回根据程序需要自动扩充大小 线程池 ----- 最常用
newSingleThreadExecutor()  返回单线程处理程序

shutdown与shutdownNow的比较
shutdown 完成当前线程池中所有任务 再关闭
shutdownNow 会对当前线程池中所有线程，调用interrupt 尝试打断当前线程，如果无法打断，会执行结束
public class ExcutorsTest {
    // java中编写程序测试多线程，一定不能用 junit --- System.exit
    public static void main(String[] args) {
        // 创建线程池
        // 创建固定数量为3 线程池
        // ExecutorService service = Executors.newFixedThreadPool(5);
        // 创建 自增扩充大小 线程池
        ExecutorService service = Executors.newCachedThreadPool();

        // 单一线程对象
        // ExecutorService service = Executors.newSingleThreadExecutor();

        // 开启十个线程 分别输出
        for (int i = 0; i < 10; i++) {
            service.execute(new MyExcutor());
        }

        // 关闭连接池
        service.shutdown();// 当之前任务都结束后，尝试关闭连接池
        // service.shutdownNow();// 尝试马上关闭连接池，但是不一定能关闭
        // interrupt
    }
}

class MyExcutor implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
------------------------------------------------------------------------------------------------------------------
OSI 七层体系结构：　应用层、表示层、会话层、传输层、网络层、数据链路层、物理层　
*协议层次越高，越容易让人理解， 层次越低，数据越接近0 1
TCP/IP 四层 ： 应用层、传输层、网际层、网络接口层

应用层、传输层
应用层：HTTP SMTP POP3 FTP TELNET
传输层：TCP（不允许丢包 三次握手） UDP（广播 允许丢包）

三次握手：
A 向 B 发送一个消息：能听到我说话吗
B 回复 A 消息：我能听到，你能听到我说话吗
A 回复 B ：我能听到

TCP发送数据没有收到对方回应，选择重新发送 ---- 时间限制 超时

Socket 两台计算机之间一个连接 ---- 两台计算机可以通信

使用socket建立双方连接 -----传输协议需要自己编写 面向底层协议

socket 编写程序 可以模拟服务器，可以模拟客户端
服务器如何编写

* 使用socket进行通信过程中，如果调用in.readLine 但是对方没有写 ---- 程序一直等待 、out.print向对方发送信息 没有阻塞
/**
 * 模拟服务器
 *
 * @author seawind
 *
 */
public class Server {
    public static void main(String[] args) throws IOException {
        // 步骤一 创建ServerSocket 对象
        ServerSocket serverSocket = new ServerSocket(9000);
        // 连接服务器需要 ip 和 端口

        // 步骤二 等待客户端来连接
        Socket socket = serverSocket.accept(); // socket代表一个连接

        // 步骤三 需要获得流
        PrintWriter out = new PrintWriter(socket.getOutputStream());
        BufferedReader in = new BufferedReader(new InputStreamReader(socket
                .getInputStream()));

        // 收取对方信息 用 in
        // 发送给对方信息 用 out

        out.println("Hello !");// 输出信息 因为用字符流 ，所以flush
        out.flush();

        System.out.println(in.readLine());
    }
}
/**
 * 客户端
 *
 * @author seawind
 *
 */
public class Client {
    public static void main(String[] args) throws UnknownHostException,
            IOException {
        // 步骤一 连接服务器
        Socket socket = new Socket("localhost", 9000);

        // 步骤二 获得流
        PrintWriter out = new PrintWriter(socket.getOutputStream());
        BufferedReader in = new BufferedReader(new InputStreamReader(socket
                .getInputStream()));

        // 通过in 获得信息
        System.out.println(in.readLine());

        out.println("你好服务器！");
        out.flush();
    }
}


socket 案例 ----- 模拟tomcat服务器

/**
 * 模拟tomcat server
 *
 * @author seawind
 *
 */
public class TomcatServer {
    public static void main(String[] args) throws IOException {
        // 步骤一
        ServerSocket serverSocket = new ServerSocket(9000);

        // 创建线程池
        ExecutorService executorService = Executors.newCachedThreadPool();

        while (true) {
            // 步骤二 获得与客户端连接
            Socket socket = serverSocket.accept();
            DealResponse dealResponse = new DealResponse(socket);
            // 将处理任务 加入线程池
            executorService.execute(dealResponse);

        }
    }

    static class DealResponse implements Runnable {
        private Socket socket;

        public DealResponse(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                // 步骤三 流
                OutputStream bout = new BufferedOutputStream(socket
                        .getOutputStream());
                // PrintWriter out = new PrintWriter(socket.getOutputStream());
                BufferedReader in = new BufferedReader(new InputStreamReader(
                        socket.getInputStream()));

                // 浏览器连接服务器 发送HTTP请求
                String requestline = in.readLine();// 获得请求行

                // 解析资源路径
                String path = parse(requestline);
                System.out.println(path);

                // 判断目标文件是否存在
                File file = new File("webroot" + path);
                // 判断服务器上面 有没有客户访问文件
                if (file.exists()) {
                    // 回写HTTP协议格式
                    bout.write("HTTP/1.1 200 OK\r\n".getBytes());

                    // 根据文件扩展名得到文件格式

                    bout
                            .write(("Content-Type:" + getType(file.getName()) + "\r\n")
                                    .getBytes()); // 不同文件类型是不同的
                    bout.write(("Content-Length:" + file.length() + "\r\n\r\n")
                            .getBytes());

                    // 存在
                    InputStream fis = new BufferedInputStream(
                            new FileInputStream(file));
                    int temp;
                    while ((temp = fis.read()) != -1) {
                        bout.write(temp);
                    }
                    bout.flush();
                    bout.close();
                    fis.close();
                    System.out.println("文件找到了");
                } else {
                    // 不存在
                    bout.write("file not found".getBytes());
                    bout.flush();
                    System.out.println("文件找不到！");
                    bout.close();
                }

                // 断开socket连接
                in.close();
                socket.close();
            } catch (FileNotFoundException e) {
                // e.printStackTrace();
            } catch (IOException e) {
                // e.printStackTrace();
            }
        }
    }

    private static String getType(String name) {
        // 获得扩展名
        String ext = name.substring(name.lastIndexOf(".") + 1);
        String type = ResourceBundle.getBundle("mime").getString(ext);
        return type;
    }

    private static String parse(String requestline) {
        return requestline.split(" ")[1];
    }

}

---------------------------------------------------------------------------------------

注解的使用 ---- 定义注解，利用反射解析注解内容 （案例：银行转账最大金额）
Servlet3.0 注解开发Servlet、异步技术、文件上传
动态代理 （案例：德华案例、银行取款 收取手续费用）
多线程：两种线程创建方式、四种状态、同步和锁、死锁、wait和notify （案例：卖票、生产蛋糕） ---- 使用JDK5 Lock和Condition 重写

socket编程 服务器怎么写 客户端怎么写
* 实际socket案例 按照协议发送内容 模拟tomcat 服务器 遵循HTTP协议