+=隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加，如byte、short或者int，首先会将它们提升到int类型，然后在执行加法操作
（因为a+b操作会将a、b提升为int类型，所以将int类型赋值给byte就会编译出错）
false，因为有些浮点数不能完全精确的表示出来
如果a和b都是对象：则a==b是比较两个对象的引用，只有当a和b指向的是堆中的同一个对象才会返回true，
如果a和b都是数值型：比较的则是数值是否相等
a.equals(b)：是进行逻辑比较（内容的比较），所以通常需要重写该方法来提供逻辑一致性的比较。例如，String类重写equals()方法，所以可以用于两个不同对象，但是包含的字母相同的比较。
==解读
对于基本类型和引用类型==的作用效果是不同的，如下所示：
Stringx="string";Stringy="string";Stringz=newString("string");System.out.println(x==y);//trueSystem.out.println(x==z);//falseSystem.out.println(x.equals(y));//trueSystem.out.println(x.equals(z));//true代码解读：因为x和y指向的是同一个引用，所以==也是true，而newString()方法则重写开辟了内存空间，所以==结果为false，而equals比较的一直是值，所以结果都为true。
equals解读(内容的比较)
equals本质上就是==，只不过String和Integer等重写了equals方法，把它变成了值比较首先来看默认情况下equals比较一个有相同值的对象，代码如下
classCat{publicCat(Stringname){this.name=name;}privateStringname;publicStringgetName(){returnname;}publicvoidsetName(Stringname){this.name=name;}}Catc1=newCat("王磊");Catc2=newCat("王磊");System.out.println(c1.equals(c2));//falseViewCode输出结果出乎我们的意料，竟然是false？这是怎么回事，看了equals源码就知道了，源码如下：
publicbooleanequals(Objectobj){return(this==obj);}原来equals本质上就是==。
那问题来了，两个相同值的String对象，为什么返回的是true？代码如下：
Strings1=newString("老王");Strings2=newString("老王");System.out.println(s1.equals(s2));//true同样的，当我们进入String的equals方法，找到了答案，代码如下：
publicbooleanequals(ObjectanObject){if(this==anObject){returntrue;}if(anObjectinstanceofString){StringanotherString=(String)anObject;intn=value.length;if(n==anotherString.value.length){charv1[]=value;charv2[]=anotherString.value;inti=0;while(n--!=0){if(v1[i]!=v2[i])returnfalse;i++;}returntrue;}}returnfalse;}ViewCode原来是String重写了Object的equals方法，把引用比较改成了值比较。
总结：==对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而equals默认情况下是引用比较，只是很多类重新了equals方法，比如String、Integer等把它变成了值比较，所以一般情况下equals比较的是值是否相等。
不对，两个对象的hashCode()相同，equals()不一定true。
代码示例：
Stringstr1="通话";Stringstr2="重地";System.out.println(String.format("str1：%d|str2：%d",str1.hashCode(),str2.hashCode()));System.out.println(str1.equals(str2));执行结果：
str1：1179395|str2：1179395false
final是一个修饰符，可以修饰变量、方法和类。
如果final修饰变量，意味着该变量的值在初始化后不能被改变。
如果final修饰类：则该类不能被继承意味着它不能再派生出新的子类
被final修饰的方法：也同样只能使用，不能覆盖(重写)。
finally是一个关键字，与try和catch一起用于异常的处理。finally块一定会被执行，无论在try块中是否有发生异常。
finalize()：这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的方法
2)继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分）。
3)封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。
4)多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。
方法重载（overload）实现的是编译时的多态性（也称为前绑定）
方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西
要实现多态需要做两件事：
1.方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
2.对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。
对于shorts1=1;s1=s1+1;由于1是int类型，因此s1+1运算结果也是int型，需要强制转换类型才能赋值给short型。
shorts1=1;s1+=1;可以正确编译，因为s1+=1;相当于s1=(short)(s1+1);其中有隐含的强制类型转换。
&运算符有两种用法：(1)按位与；(2)逻辑与。
&&运算符是短路与运算。
2<<3（左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方）
抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。
相同点：
不同点：
抽象类中可以定义构造器，可以有抽象方法和具体方法，
抽象类中的成员可以是private、默认、protected、public的
接口中不能定义构造器而且其中的方法全部都是抽象方法。
接口中的成员全都是public的
接口中定义的成员变量实际上都是常量。
不能，定义抽象类就是让其他类继承的，如果定义为final该类就不能被继承，这样彼此就会产生矛盾，所以final不能修饰抽象类
实现：抽象类的子类使用extends来继承；接口必须使用implements来实现接口。构造函数：抽象类可以有构造函数；接口不能有。main方法：抽象类可以有main方法，并且我们能运行它；接口不能有main方法。实现数量：类可以实现很多个接口；但是只能继承一个抽象类。访问修饰符：接口中的方法默认使用public修饰；抽象类中的方法可以是任意访问修饰符。
两个对象，一个是静态存储区的"xyz",一个是用new创建在堆上的对象。
①SpringIoC容器找到关于Bean的定义并实例化该Bean。②SpringIoC容器对Bean进行依赖注入。③如果Bean实现了BeanNameAware接口，则将该Bean的id传给setBeanName方法。④如果Bean实现了BeanFactoryAware接口，则将BeanFactory对象传给setBeanFactory方法。⑤如果Bean实现了BeanPostProcessor接口，则调用其postProcessBeforeInitialization方法。⑥如果Bean实现了InitializingBean接口，则调用其afterPropertySet方法。⑦如果有和Bean关联的BeanPostProcessors对象，则这些对象的postProcessAfterInitialization方法被调用。⑧当销毁Bean实例时，如果Bean实现了DisposableBean接口，则调用其destroy方法。
启动类上面的注解是@SpringBootApplication，它也是SpringBoot的核心注解，主要组合包含了以下3个注解：
@SpringBootConfiguration：组合了@Configuration注解，实现配置文件的功能。
@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能：@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})。
@ComponentScan：Spring组件扫描。
clone(),equals(),hashCode(),toString(),notify(),notifyAll(),wait(),finalize(),getClass()
String不属于基础类型，基础类型有8种：byte、boolean、char、short、int、float、long、double，而String属于对象
操作字符串的类有：String、StringBuffer、StringBuilder。
String和StringBuffer、StringBuilder的区别
StringBuffer、StringBuilder可以在原有对象的基础上进行操作，所以在经常改变字符串内容的情况下最好不要使用String。
StringBuffer和StringBuilder最大的区别：
StringBuffer是线程安全的，而StringBuilder是非线程安全的，但StringBuilder的性能却高于StringBuffer，所以在单线程环境下推荐使用StringBuilder，多线程环境下推荐使用StringBuffer。
不一样，因为内存的分配方式不一样。Stringstr="i"的方式，java虚拟机会将其分配到常量池中；而Stringstr=newString("i")则会被分到堆内存中。
使用StringBuilder或者stringBuffer的reverse()方法。
//StringBufferreverseStringBufferstringBuffer=newStringBuffer();stringBuffer.append("abcdefg");System.out.println(stringBuffer.reverse());//gfedcba//StringBuilderreverseStringBuilderstringBuilder=newStringBuilder();stringBuilder.append("abcdefg");System.out.println(stringBuilder.reverse());//gfedcba18）String类的常用方法都有那些？indexOf()：返回指定字符的索引。charAt()：返回指定索引处的字符。replace()：字符串替换。trim()：去除字符串两端空白。split()：分割字符串，返回一个分割后的字符串数组。getBytes()：返回字符串的byte类型数组。length()：返回字符串长度。toLowerCase()：将字符串转成小写字母。toUpperCase()：将字符串转成大写字符。substring()：截取字符串。equals()：字符串比较。
按功能来分：输入流（input）、输出流（output）。
按类型来分：字节流和字符流。
字节流和字符流的区别是：字节流按8位传输以字节为单位输入输出数据，字符流按16位传输以字符为单位输入输出数据。
BIO：BlockIO同步阻塞式IO，就是我们平常使用的传统IO，它的特点是模式简单使用方便，并发处理能力低。NIO：NewIO同步非阻塞IO，是传统IO的升级，客户端和服务器端通过Channel（通道）通讯，实现了多路复用。AIO：AsynchronousIO是NIO的升级，也叫NIO2，实现了异步非堵塞IO，异步IO的操作基于事件和回调机制。
Files.exists()：检测文件路径是否存在。Files.createFile()：创建文件。Files.createDirectory()：创建文件夹。Files.delete()：删除一个文件或目录。Files.copy()：复制文件。Files.move()：移动文件。Files.size()：查看文件个数。Files.read()：读取文件。Files.write()：写入文件。
hashMap去掉了HashTable的contains方法，但是加上了containsValue（）和containsKey（）方法。hashTable同步的，而HashMap是非同步的，效率上逼hashTable要高。hashMap允许空键值，而hashTable不允许。
HashMap概述：HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
HashMap的数据结构：在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
当我们往Hashmap中put元素时,首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上。
①.继承Thread类创建线程类
定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。创建Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。②.通过Runnable接口创建线程类
定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。创建Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。调用线程对象的start()方法来启动该线程。③.通过Callable和Future创建线程
创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。使用FutureTask对象作为Thread对象的target创建并启动新线程。调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
有点深的问题了，也看出一个Java程序员学习知识的广度。
Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果
线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。
因为sleep()是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep()方法，线程虽然进入休眠，但是对象的机锁（cpu）没有被释放，其他线程依然无法访问这个对象。
如果线程调用了对象的wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。当有线程调用了对象的notifyAll()方法（唤醒所有wait线程）或notify()方法（只随机唤醒一个wait线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。
也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了synchronized代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
start()方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；这时此线程是处于就绪状态，并没有运行。然后通过此Thread类调用方法run()来完成其运行状态，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程终止。然后CPU再调度其它线程。
run()方法是在本线程里的，只是线程里的一个函数,而不是多线程的。如果直接调用run(),其实就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。
①.newFixedThreadPool(intnThreads)
创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程。
②.newCachedThreadPool()
创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。
③.newSingleThreadExecutor()
这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行。
④.newScheduledThreadPool(intcorePoolSize)
创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。
接收的参数不一样submit有返回值，而execute没有submit方便Exception处理
线程安全在三个方面体现：
原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。是操作系统层面的一个错误，是进程死锁的简称，最早在1965年由Dijkstra在研究银行家算法时提出的，它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。
死锁的四个必要条件：
互斥条件：进程对所分配到的资源不允许其他进程进行访问，若其他进程访问该资源，只能等待，直至占有该资源的进程使用完成后释放该资源请求和保持条件：进程获得一定的资源之后，又对其他资源发出请求，但是该资源可能被其他进程占有，此事请求阻塞，但又对自己获得的资源保持不放不可剥夺条件：是指进程已获得的资源，在未完成使用之前，不可被剥夺，只能在使用完后自己释放环路等待条件：是指进程发生死锁后，若干进程之间形成一种头尾相接的循环等待资源关系这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁
synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
普通同步方法，锁是当前实例对象静态同步方法，锁是当前类的class对象同步方法块，锁是括号里面的对象
volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。
首先synchronized是java内置关键字，在jvm层面，Lock是个java类；synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；synchronized会自动释放锁(a线程执行完同步代码会释放锁；b线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；
jsp经编译后就变成了Servlet.（JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码，Web容器将JSP的代码编译成JVM能够识别的java类）jsp更擅长表现于页面显示，servlet更擅长于逻辑控制。Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到。Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。
JSP有9个内置对象：
request：封装客户端的请求，其中包含来自GET或POST请求的参数；response：封装服务器对客户端的响应；pageContext：通过该对象可以获取其他对象；session：封装用户会话的对象；application：封装服务器运行环境的对象；out：输出服务器响应的输出流对象；config：Web应用的配置对象；page：JSP页面本身（相当于Java程序中的this）；exception：封装页面抛出异常的对象。
JSP中的四种作用域包括page、request、session和application，具体来说：
由于HTTP协议是无状态的协议，所以服务端需要记录用户的状态时，就需要用某种机制来识具体的用户，这个机制就是Session.
典型的场景比如购物车，当你点击下单按钮时，由于HTTP协议无状态，所以并不知道是哪个用户操作的，所以服务端要为特定的用户创建了特定的Session，用用于标识这个用户，并且跟踪用户，这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个唯一标识。在服务端保存Session的方法很多，内存、数据库、文件都有。集群的时候也要考虑Session的转移，在大型的网站，一般会有专门的Session服务器集群，用来保存用户会话，这个时候Session信息都是放在内存的，使用一些缓存服务比如Memcached之类的来放Session。思考一下服务端如何识别特定的客户？
这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用Cookie来实现Session跟踪的，第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在Cookie里面记录一个SessionID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了
如果客户端的浏览器禁用了Cookie怎么办？
session是一个存在服务器上的类似于一个散列表格的文件。里面存有我们需要的信息，在我们需要用的时候可以从里面取出来。类似于一个大号的map吧，里面的键存储的是用户的sessionid，用户向服务器发送请求的时候会带上这个sessionid。这时就可以从中取出对应的值了。
Cookie与Session，一般认为是两个独立的东西，Session采用的是在服务器端保持状态的方案，而Cookie采用的是在客户端保持状态的方案。
为什么禁用Cookie就不能得到Session呢？
因为Session是用SessionID来确定当前对话所对应的服务器Session，而SessionID是通过Cookie来传递的，禁用Cookie相当于失去了SessionID，也就得不到Session了。
假定用户关闭Cookie的情况下使用Session，其实现途径有以下几种：
1）设置php.ini配置文件中的“session.use_trans_sid=1”，或者编译时打开打开了“--enable-trans-sid”选项，让PHP自动跨页传递SessionID。2）手动通过URL传值、隐藏表单传递SessionID。3）用文件、数据库等形式保存SessionID，在跨页过程中手动调用。
拦截机制的不同Struts2是类级别的拦截，每次请求就会创建一个Action，和Spring整合时Struts2的ActionBean注入作用域是原型模式prototype，然后通过setter，getter吧request数据注入到属性。
Struts2中，一个Action对应一个request，response上下文，在接收参数时，可以通过属性接收，这说明属性参数是让多个方法共享的。
Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了，只能设计为多例。
SpringMVC是方法级别的拦截，一个方法对应一个Request上下文，所以方法直接基本上是独立的，独享request，response数据。而每个方法同时又何一个url对应，参数的传递是直接注入到方法中的，是方法所独有的。
处理结果通过ModeMap返回给框架。在Spring整合时，SpringMVC的ControllerBean默认单例模式Singleton，所以默认对所有的请求，只会创建一个Controller，有应为没有共享的属性，所以是线程安全的，
如果要改变默认的作用域，需要添加@Scope注解修改。
Struts2有自己的拦截Interceptor机制，SpringMVC这是用的是独立的Aop方式，这样导致Struts2的配置文件量还是比SpringMVC大。
底层框架的不同Struts2采用Filter（StrutsPrepareAndExecuteFilter）实现
SpringMVC（DispatcherServlet）则采用Servlet实现。Filter在容器启动之后即初始化；服务停止以后坠毁，晚于Servlet。Servlet在是在调用时初始化，先于Filter调用，服务停止后销毁。
性能方面Struts2是类级别的拦截，每次请求对应实例一个新的Action，需要加载所有的属性值注入
SpringMVC实现了零配置，由于SpringMVC基于方法的拦截，有加载一次单例模式bean注入。所以，SpringMVC开发效率和性能高于Struts2。
配置方面springMVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高。
XSS攻击又称CSS,全称CrossSiteScript（跨站脚本攻击），其原理是攻击者向有XSS漏洞的网站中输入恶意的HTML代码，当用户浏览该网站时，这段HTML代码会自动执行，从而达到攻击的目的。XSS攻击类似于SQL注入攻击，SQL注入攻击中以SQL语句作为用户输入，从而达到查询/修改/删除数据的目的，而在xss攻击中，通过插入恶意脚本，实现对用户游览器的控制，获取用户的一些信息。XSS是Web程序中常见的漏洞，XSS属于被动式且用于客户端的攻击方式。
XSS防范的总体思路是：对输入(和URL参数)进行过滤，对输出进行编码。
如何避免：
1.验证HTTPReferer字段
2.使用验证码
关键操作页面加上验证码，后台收到请求后通过判断验证码可以防御CSRF。但这种方法对用户不太友好。
3.在请求地址中添加token并验证
4.在HTTP头中自定义属性并验证
这种方法也是使用token并进行验证，和上一种方法不同的是，这里并不是把token以参数的形式置于HTTP请求之中，而是把它放到HTTP头中自定义的属性里。通过XMLHttpRequest这个类，可以一次性给所有该类请求加上csrftoken这个HTTP头属性，并把token值放入其中。这样解决了上种方法在请求中加入token的不便，同时，通过XMLHttpRequest请求的地址不会被记录到浏览器的地址栏，也不用担心token会透过Referer泄露到其他网站中去。
严格限制Web应用的数据库的操作权限，给连接数据库的用户提供满足需要的最低权限，最大限度的减少注入攻击对数据库的危害校验参数的数据格式是否合法（可以使用正则或特殊字符的判断）对进入数据库的特殊字符进行转义处理，或编码转换预编译SQL（Java中使用PreparedStatement），参数化查询方式，避免SQL拼接发布前，利用工具进行SQL注入检测报错信息不要包含SQL信息输出到Web页面
throw则是指抛出的一个具体的异常类型。
Forward和Redirect代表了两种请求转发方式：直接转发和间接转发。
直接转发方式（Forward），客户端和浏览器只发出一次请求，Servlet、HTML、JSP或其它信息资源，由第二个信息资源响应该请求，在请求对象request中，保存的对象对于每个信息资源是共享的。
间接转发方式（Redirect）实际是两次HTTP请求，服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的。
举个通俗的例子：
直接转发就相当于：“A找B借钱，B说没有，B去找C借，借到借不到都会把消息传递给A”；
间接转发就相当于："A找B借钱，B说没有，让A去找C借"。
应用层：网络服务与最终用户的一个接口。表示层：数据的表示、安全、压缩。会话层：建立、管理、终止会话。传输层：定义传输数据的协议端口号，以及流控和差错校验。网络层：进行逻辑地址寻址，实现不同网络之间的路径选择。数据链路层：建立逻辑连接、进行硬件地址寻址、差错校验等功能。物理层：建立、维护、断开物理连接。
Spring通过DI（依赖注入）实现IOC（控制反转），常用的注入方式主要有三种：
Spring运行流程描述：
1.用户向服务器发送请求，请求被Spring前端控制ServeltDispatcherServlet捕获；
3.DispatcherServlet根据获得的Handler，选择一个合适的HandlerAdapter；（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）
4.提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
HttpMessageConveter：将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息数据转换：对请求消息进行数据转换。如String转换成Integer、Double等数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中5.Handler执行完成后，向DispatcherServlet返回一个ModelAndView对象；
6.根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet；
7.ViewResolver结合Model和View，来渲染视图；
8.将渲染结果返回给客户端。
SpringMVC的核心组件：
DispatcherServlet：中央控制器，把请求给转发到具体的控制类Controller：具体处理请求的控制器HandlerMapping：映射处理器，负责映射中央处理器转发给controller时的映射策略ModelAndView：服务层返回的数据和视图层的封装类ViewResolver：视图解析器，解析具体的视图Interceptors：拦截器，负责拦截我们定义的请求然后做处理工作
RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
RequestMapping注解有六个属性，下面我们把她分成三类进行说明。
value，method：
value：指定请求的实际地址，指定的地址可以是URITemplate模式（后面将会说明）；method：指定请求的method类型，GET、POST、PUT、DELETE等；consumes，produces
consumes：指定处理请求的提交内容类型（Content-Type），例如application/json,text/html；produces：指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；params，headers
params：指定request中必须包含某些参数值时，才让该方法处理。headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。
都不能
抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。
本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。
synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。
待续........
---------------------
个性签名：真正的学习不是记住知识，而是学会如何提出问题，研究问题，解决问题。