注解

注解的基本知识：

1.示列

@Deprecated ：标注XX过时

@SuppressWarning：抑制警告：unused：抑制的警告类型{ "unused", "rawtypes", "unchecked" }：数组，抑制的多个警告类型；all:抑制所有警告

@Override：保证用户确实是覆盖了父类的某个方法。

2.自定义注解

使用@interface关键字来声明注解；public @interface MyAnn1{}；声明注解的属性字段：类型   字段名（）[defalut  默认值]；

注解的类型只能是下面的几个：String     Class     八个类型     注解类型     枚举类型     及以上类型的1维数组；

特殊属性：String    value；或者String[]  value()；   使用时候直接给定取值，而不用加属性名称；

3.元注解

服务于注解的注解就是元注解

@Retention：指定注解的存活范围。默认是CLASS

RetentionPolicy：SOURCE|CLASS|RUNTIME

@Target：指定注解可以用在什么元素上

ElementType：TYPE|METHOD|。。。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyTest {
    long time() default -1;
}

@Documented: 用于指定被该元 Annotation 修饰的 Annotation 类将被 javadoc 工具提取成文档.

@Inherited: 被它修饰的 Annotation 将具有继承性.如果某个类使用了被 @Inherited 修饰的 Annotation, 则其子类将自动具有该注解

注解的反射

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//反射注解：所有注解类型都是Annotation类型的子类
/*
java.lang.reflect.AnnotatedElement:
    <T extends Annotation> getAnnotation(Class<T> annotationType):
        获取指定类型的注解
    Annotation[] getAnnotations():获取所有的注解
    Annotation[] getDeclareAnnotations():返回直接存在于此元素上的所有注释
    boolean isAnnotationPresend(Class<? extends Annotation>):有木有指定的注解
    
    Class, Constructor, Field, Method, Package都实现了该接口
 */
public class MyTestRunner {
    //执行测试:
    /*
     * 获取要测试的java类：MyJunitTest
     * 取到其中的所有方法：Method
     * 看看谁的方法前面有@MyTest的注解，谁有就执行谁
     */
    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException {
        test2();
    }
    //反射带有属性的注解
    private static void test2() throws IllegalAccessException,
            InvocationTargetException, InstantiationException {
        Class clazz = MyJunitTest.class;
        Method ms[] = clazz.getMethods();
        for(Method m:ms){
            MyTest myTest = m.getAnnotation(MyTest.class);
            if(myTest!=null){
                //得到注解的属性
                long timeLimit = myTest.time();
                if(timeLimit>-1){
                    //有性能测试需求
                    long startTime = System.nanoTime();
                    m.invoke(clazz.newInstance(), null);
                    long useTime = System.nanoTime()-startTime;
                    if(useTime>timeLimit){
                        System.out.println(m.getName()+"执行效率没有测试通过");
                    }
                }else{
                    //没有性能测试需求
                    m.invoke(clazz.newInstance(), null);
                }
                
            }
        }
    }
    //注解的基本反射
    private static void test1() throws IllegalAccessException,
            InvocationTargetException, InstantiationException {
        Class clazz = MyJunitTest.class;
        Method ms[] = clazz.getMethods();
        for(Method m:ms){
            boolean b = m.isAnnotationPresent(MyTest.class);
//            System.out.println(m.getName()+"方法上有木有MyTest注解："+b);
            if(b){
                m.invoke(clazz.newInstance(), null);
            }
        }
    }

}

1. 指定运行时生命周期才能进行测试

 2.指定在指定时间内执行完，才算是测试成功

注解

替换传统的XML配置文件。 

比如：映射一个Servlet

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

public class MyServlet extends HttpServlet{

... 

}

web.xml

<servlet>

 

<servlet-name>MyServlet</servlet-name>

 

<servlet-class>com.itheima.MyServlet</servlet-class>

 

</servlet>

 

<servlet-mapping>

 

<servlet-name>MyServlet</servlet-name>

 

<url-pattern>/servlet/MyServlet</url-pattern>

 

</servlet-mapping>

 

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

 

@WebServlet(urlPattern=”/servlet/MyServlet”)
public class MyServlet extends HttpServlet{}

 Servlet3.0的新特征 

JavaEE5.0：Servlet2.5

JavaEE6.0：Servlet3.0

1、前提：

Tomcat7.X   JDK6.X

2、Servlet3.0比Servlet2.5多了哪些功能

1.不用配置xml文件的设置，用注解

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(urlPatterns="/servlet/ServletDemo1",initParams=@WebInitParam(name="encoding",value="ANNVAUE"))

//注册配置的和web.xml配置的都会实例化一次
//建议：要么用注解，要么用web.xml
public class ServletDemo extends HttpServlet {
    public void init() throws ServletException {
        System.out.println("初始化了");
    }
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        System.out.println(this);
        System.out.println("ServletDemo1执行了");
        String value = getServletConfig().getInitParameter("encoding");
        System.out.println(value);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

}

ServletDemo1

2.文件上传的改变

2.1：上传形式不变：

　　　　　　

2.2：

import java.io.IOException;
import java.util.Collection;
import java.util.Collections;

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;
@WebServlet("/servlet/UploadServlet")
@MultipartConfig //告知处理的是multipart/form-data类型的数据
public class UploadServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
//        Collection<Part> parts = request.getParts();
//        for(Part p:parts)
//            System.out.println(p);
        
        //传统方式获取参数能用了
//        String name = request.getParameter("name");
//        System.out.println(name);
        
        //处理文件上传
        Part part = request.getPart("photo");
        //获取上传文件的文件名
        String headerValue = part.getHeader("Content-Disposition");//  form-data; name="photo"; filename="AOP.txt"
        int index = headerValue.indexOf("filename=");
        String filename = headerValue.substring(index+10, headerValue.length()-1);
        part.write(getServletContext().getRealPath("/files")+"/"+filename);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

}

UploadServlet

3.web片段：

注解的引入使得web.xml变成可选的了。但是，我们还是可以使用web.xml。容器会根据web.xml中的metadata- complete元素的值来决定使用web.xml还是使用注解。如果该元素的值是true，那么容器不处理注解，web.xml是所有信息的来源。如果 该元素不存在或者其值不为true，容器才会处理注解。

Web框架的可插入性

我们前面说过了Servlet3.0的改进之一就是使得我们能够将框架和库插入到web应用程序中。这种可插入性减少了配置，并且提高了web应用程序的模块化。Servlet3.0是通过web模块布署描述片段（简称web片段）来实现插入性的。
一个web片段就是web.xml文件的一部分，被包含在框架特定的Jar包的META-INF目录中。Web片段使得该框架组件逻辑上就是web应用程序的一部分，不需要编辑web布署描述文件。
Web 片段中使用的元素和布署文件中使用的元素基本相同，除了根元素不一样。Web片段的根元素是<web-fragment>,而且文件名必须叫 做web-fragment.xml。容器只会在放在WEB-INFlib目录下的Jar包中查找web-fragment.xml文件。如果这些 Jar包含有web-fragment.xml文件，容器就会装载需要的类来处理他们。
在web.xml中，我们要求Servlet的name必须唯一。同样的，在web.xml和所有的web片段中，Servlet的name也必须唯一。
下面就是一个web-fragment的例子：

<web-fragment>
<servlet>
<servlet-name>ControllerServlet</servlet-name>
<servlet-class>com.app.control.ControllerServlet</servlet-class>
</servlet>
<listener> <listener-class>com.listener.AppServletContextListener</listener-class>
</listener>

框架的Jar包是放在WEB-INFlib目录下的，但是Servlet3.0提供两种方法指定多个web片段之间的顺序：
   1. 绝对顺序
   2. 相对顺序
我 们通过web.xml文件中的<absolute-ordering>元素来指定绝对顺序。这个元素有之元素name，name的值是各个 web片段的name元素的值。这样就指定了web片段的顺序。如果多个web片段有相同的名字，容器会忽略后出现的web片段。下面是一个指定绝对顺序 的例子：

 <web-app>
<name>DemoApp</name>
<absolute-ordering>
<name>WebFragment1</name>
<name>WebFragment2</name>
</absolute-ordering>
 </web-app>

相对顺序通过web-fragment.xml中的<ordering>元素来确定。Web片段的顺序 由<ordering>的子元素<before>,<after>和<others>来决定。当前的 web片段会放在所有的<before>元素中的片段之前。同样的，会放在所有的<after>元素中的片段之 后。<others>用来代替所有的其他片段。注意只有当web.xml中没有<absolute-ordering>时，容器 才会使用web片段中定义的相对顺序。
下面是一个帮助理解相对顺序的例子：

<web-fragment>
<name>WebFragment1</name>
<ordering><after>WebFragment2</after></ordering>
</web-fragment>

<web-fragment>
<name>WebFragment2</name>
</web-fragment>

<web-fragment>
<name>WebFragment3</name>
<ordering><before><others/></before></ordering>
</web-fragment>

这些文件将会按照下面的顺序被处理：

   1. WebFragment3
   2. WebFragment2
   3. WebFragment1

包含WebFragment3的Jar文件被最先处理，包含WebFragment2的文件被第二个处理，包含WebFragment1的文件被最后处理。
如果既没有定义绝对顺序，也没有定义相对顺序，那么容器就认为所有的web片段间没有顺序上的依赖关系。

4.同步和异步：

同步：

同步的思想是：所有的操作都做完，才返回给用户。这样用户在线等待的时间太长，给用户一种卡死了的感觉（就是系统迁移中，点击了迁移，界面就不动了，但是程序还在执行，卡死了的感觉）。这种情况下，用户不能关闭界面，如果关闭了，即迁移程序就中断了。

异步：

将用户请求放入消息队列，并反馈给用户，系统迁移程序已经启动，你可以关闭浏览器了。然后程序再慢慢地去写入数据库去。这就是异步。但是用户没有卡死的感觉，会告诉你，你的请求系统已经响应了。你可以关闭界面了。

同步，是所有的操作都做完，才返回给用户结果。即写完数据库之后，在相应用户，用户体验不好。

异步，不用等所有操作等做完，就相应用户请求。即先相应用户请求，然后慢慢去写数据库，用户体验较好。

异步操作例子：

为了避免短时间大量的数据库操作，就使用缓存机制，也就是消息队列。先将数据放入消息队列，然后再慢慢写入数据库。

引入消息队列机制，虽然可以保证用户请求的快速响应，但是并没有使得我数据迁移的时间变短（即80万条数据写入mysql需要1个小时，用了redis之后，还是需要1个小时，只是保证用户的请求的快速响应。用户输入完http url请求之后，就可以把浏览器关闭了，干别的去了。如果不用redis，浏览器不能关闭）。

同步就没有任何价值了吗？银行的转账功能。

 

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(urlPatterns="/RegistServlet",asyncSupported=true)
public class RegistServlet extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.write("RegistServlet开始运行了<br/>");
        out.flush();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        out.write("注册成功了<br/>");
        out.flush();
        //发送激活邮件
        AsyncContext ac = request.startAsync();//开始异步
        new Thread(new SendMail(ac)).start();//3秒
        out.write("RegistServlet运行结束了<br/>");
        out.flush();
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

}
class SendMail implements Runnable{

    private AsyncContext ac;

    public SendMail(AsyncContext ac) {
        this.ac= ac;
    }

    public void run() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打印信息
        try {
            PrintWriter out = ac.getResponse().getWriter();
            out.write("邮件发送成功!");
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}