Java-ZZH1-78面试题

ZZH 1-78

hollerJAVA总结
目录
总结 1
1.JDK 1
1、 JAVA开发工具(jdk\bin) 1
2、 基础开发库(jdk\jre\lib\rt.jar) 1
3、 基础开发库的源码(jdk\src.zip) 1
2.基本类型(八种) 1
整数型 1
浮点型 2
3.运算符 2
算术运算符 + - * / 2
比较运算符 2
逻辑运算符 2
三元运算符 3
三项运算 3
赋值运算符 3
赋值运算 3
复合的赋值运算 3
4.循环结构 3
for(开始条件；循环条件；更改条件){ 4
嵌套for循环 4
5：break和continue 4
break: 中断当前循环，简单粗暴 4
continue：跳出本次循环，进入下一轮 5
while 5
do-while 6
6：数组 6
动态初始化：int[] a = new int[5]; 6
静态初始化1：int[] a ={1,2,3,4,5,6,7,8}; 6
数组的长度 6
数组的遍历 7
数组工具类Arrays 7
Arrays.sort(数组) 7
Arrays.copyOf(数组，新的长度) 7
7.方法 8
方法的重载 8
8.字符串 8
9.equals与==的区别 8
10.面向对象 9
三大特征 9
11.方法重写与重载 9
重写(Override) 9
重载(Overload) 10
12.抽象类 接口 10
抽象类： 10
接口 10
接口的实现 11
抽象类 接口的区别 11
13.访问控制权限4种 11
public? 公开的 12
protected? 受保护的 12
private? ?私有的 12
default?? 默认 12
14.多线程 12
线程（thread） 12

1. 新建状态（New）： 13
2. 就绪状态（Runnable）： 13
3. 运行状态（Running）： 13
4. 阻塞状态（Blocked）： 13
5. 根据阻塞产生的原因不同，阻塞状态又可以分为三种： 14
6. 死亡状态（Dead）： 14
   15.集合 14
   集合：集合是java中提供的一种容器，可以用来存储多个数据。 15
   Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。 15
   List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList， 15
   Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。 15
   Collection 常用功能 15
   Iterator接口 15
   泛型：可以在类或方法中预支地使用未知的类型。一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。 16
   16.IO流 16
   字节流 17
   字节文件操作流 17
   字节缓冲流（高效流） 17
   字符流 17
   字符转换流 18
   字符缓冲流（高效流） 18
   17.什么是数据库? 18
   18.mysql数据类型有哪些？ 19
   1、数值类型 19
   2、 浮点型 float double 19
   3.日期和时间类型 19
   4 字符串类型 20
   19.mysql的约束有哪些？ 20
   1、非空约束(not null) 20
   2、唯一性约束(unique) 20
   3、主键约束(primary key) 20
   4、外键约束(foreign key) 21
   5、默认值约束 (Default) 21
   6、自增约束(AUTO_INCREMENT) 21
   20.什么是事务？事物的特点？事物的作用？ 22
   21.什么是JDBC？ 22
   22.JDBC连接数据库的过程？ 22
   6.释放资源 23
   23.如何防止sql注入攻击？ 23
   如何防止SQL注入攻击？ 23
   24.什么是连接池？使用连接池的好处？ 23
   连接池： 23
   好处： 24
   25.什么是HTML？ 24
   26.html的结构是什么样的？ 24
   (1) 24
   (2) 24
   (3) 25
   (4) 25
   (5) 25
   27.什么是HTML的标签和属性？ 25
   28.什么是超链接？有哪些属性？ 25
   29.表单一般包含哪些元素？ 26
   30.什么是css? 26
   31.在HTML中引入css的方式有几种？优先级 26
   方式1：通过style属性引入css（不推荐） 26
   方式2：通过style标签引入css 26
   方式3：通过link链接引入外部的css文件 27
   32.css的选择器有哪些？ 27
   33.css元素类型有哪些？块、行内元素 28
   元素类型分类： 28
   块状元素特点： 28
   内联元素特点： 28
   34.什么是JS？有什么特点？优势是什么？ 28
   全称叫做JavaScript，简称叫做JS 28
   特点： 29
   优势： 29
   35.在HTML中如何引入js? 29
   1、在script标签内部可以书写JS代码：36.js如何获取表单内容？ 30
   2、通过script标签引入外部的JS文件 30
   37.什么是JQ？有什么优势？ 30
   jQuery是一门轻量的、免费开源的JS函数库（就是JS的简单框架） 30
   优势： 30
   38.如何引入JQ？ 31
   39.JQuery的常用选择器有哪些？ 31
   1、基本选择器： 31
   2、层级选择器 32
   3、基本过滤选择器 32
   4、可见性过滤选择器 33
   40、什么是服务器？什么 是web服务器？ 33
   服务器： 33
   web服务器： 34
   41、tomcat默认端口是什么？如何修改？ 34
   Tomcat端口号： 34
   修改端口： 34
   42、什么是Http协议？Http协议在工作时遵循什么原则？ 41
   Http协议： 41
   遵循原则： 41
   43、请求方式GET和POST 的区别？ 41
   44、什么是Servlet?Servlet的作用是什么？ 42
   Servlet： 42
   作用： 43
   45、如何开发一个Servlet程序？ 44
   开发Servlet程序的步骤 44
   使用Eclipse创建Servlet 46
   1、选中项目中的src目录，鼠标右键 —> New —> Servlet 46
   2、在弹出的窗口中，根据提示填写内容 47
   3、点击finish即可完成Servlet创建过程, 创建好的Servlet如下: 47
   46、Servlet生命周期是什么？ 51
   47、Servlet数据传递的范围有几种？分别是什么？ 51
   48、什么是Cookie和Session？ 52
   Cookie 53
   Session 53
   总结:两者的区别 53
   49、转发和重定向的区别？ 55
   转发： 55
   重定向： 55
   50、什么是jsp？ 56
   51、jsp有多少内置对象，分别说明？ 57
   1、request对象 58
   2、response对象 69
   3、session对象 72
   4、application对象 74
   5、out对象 76
   6、获取会话范围的pageContext对象 79
   7、读取web.xml配置信息的config对象 80
   8、应答或请求的page对象 80
   9、获取异常信息的exception对象 81
   52、Jsp的域对象有哪些？ 83
   Maven: 翻译为"专家"、“内行”，是Apache下的一个纯Java开发的一个开源项目。 84
   54、什么是mybatis?使用mybatis有什么优势？ 86
   55、mybatis中#{}与${}的区别？ 87
   #{}： 88
   相当于JDBC中的问号（?）占位符，是为SQL语句中的参数值进行占位，大部分情况下都是使用#{}占位符；并且当#{}占位符是为字符串或者日期类型的值进行占位时，在参数值传过来替换占位符的同时，会进行转义处理（在字符串或日期类型的值的两边加上单引号） 88
   ${}： 88
   56、什么是动态SQL?什么情况下使用动态SQL？ 88
   57、动态SQL常用标签有哪些？ 88
   Mybatis动态sql（有哪些）标签： 88
   58、什么是Spring？它的优势是什么？ 90
   59、Spring的核心内容是什么？ 91
   60.IOC、AOP各是什么 93
   61.什么是MVC?工作原理？ 94
   MVC就是一种设计模式，它就是强制性使应用程序的输入，处理和输出分开。将一个应用程序分为三个部分：Model，View，Controller。 94
   springmvc的工作原理是： 94
   62.springboot？ 95
   63.1.什么是AOP（Aspect Orient Programming）？解决了什么问题？应用原理?应用场景 95
   ? 95
   2.解决的问题 95
   3.应用原理 95
   4.应用场景 96

总结
1.JDK
是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心。
它包含了:
1、 JAVA开发工具(jdk\bin)
2、 基础开发库(jdk\jre\lib\rt.jar)
3、 基础开发库的源码(jdk\src.zip)
2.基本类型(八种)
整数型
byte 1 -27到27-1 或者 -128到127
short 2 -215到215-1
int 4 -231到231-1
long 8 -263到263-1
浮点型
float 4 单精度，对小数部分的精度要求不高
double 8 双精度，精确的小数部分并操作值很大时
字符
char 2 0到65535
布尔
boolean 1 真true 假false
3.运算符
算术运算符 + - * /
基本运算 % 取余数，求模，算整除
++ – 自增 自减
比较运算符
== 相等比较
！= 不等比较
逻辑运算符
&& & 逻辑与(短路与)，两边同为真结果才为真
|| | 逻辑或(短路或)，两边只要有一个真结果就是真

• 字符串连接
  ！ 非，非真是假，非假是真
  三元运算符
  ？：
  三项运算
  1?2:3
  1是真取2，1是假取3
  赋值运算符
  =
  赋值运算
  += -=
  *= /=
  复合的赋值运算
  a+=2;//a=a+2
  4.循环结构
  循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
  它由循环体中的条件，判断继续执行某个功能还是退出循环。
  根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构
  for(开始条件；循环条件；更改条件){
  循环体代码…
  }
  嵌套for循环
  根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断
  for(…){
  for(…){
  }
  }
  5：break和continue
  用来终止循环，可以用两种方式
  break: 中断当前循环，简单粗暴
  for(){
  代码1
  if(条件){
  代码3…
  break;//如果成立，直接跳出这个for循环
  }
  代码2…
  }
  continue：跳出本次循环，进入下一轮
  for(){
  代码1
  if(条件){
  代码3…
  continue;//如果成立，跳出本次for循环，进入下一轮
  }
  代码2…
  }
  while
  先判断，再执行
  while(执行条件){
  代码…
  }
  do-while
  先执行，再判断
  do{
  代码…
  }while(执行条件);
  6：数组
  概念:数组Array是用于储存多个相同类型数据的集合。
  想要获取数组中的元素值，可以通过元素的下标来获取，下标是从0开始的。
  动态初始化：int[] a = new int[5];
  静态初始化1：int[] a ={1,2,3,4,5,6,7,8};
  静态初始化2：int[] a =new int[]{1,2,3,4,5};
  数组的长度
  ? length属性获取数组长度
  ? 数组一旦创建，长度不可变
  ? 允许0长度的数组
  数组的遍历
  从头到尾，依次访问数组的位置。
  形式
  for(int i=0;i syso(a[i]);
  }
  数组工具类Arrays
  Arrays.toString(数组)
  把数组里的数据，用逗号连接成一个字符串。
  格式：[10, 14, 20, 46, 51]
  Arrays.sort(数组)
  对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
  对引用类型数组，使用优化后的合并排序算法。
  Arrays.copyOf(数组，新的长度)
  把数组复制成一个指定长度的新数组。
  新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容
  新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容
  7.方法
  被命名的代码块，方法可以含参数可以不含参数
  可以提高代码的复用性
  修饰符 返回值 方法名(【参数】){
  方法体;
  }
  方法的重载
  概念：方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。
  程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。
  8.字符串
  String 字符串常量
  StringBuffer 字符串变量（线程安全的）
  StringBuilder 字符串变量（非线程安全的）
  9.equals与的区别
  当比较基本类型时，用
  当比较的元素为引用类型时，==比较的是内存地址
  == 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作
  equals比较引用类型，比较的是值，而不是地址
  10.面向对象
  所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。
  我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）
  三大特征
  1、 封装性，把相关的数据封装成一个“类”组件
  2、 继承性，是子类自动共享父类属性和方法，这是类之间的一种关系
  3、 多态，增强软件的灵活性和重用性
  11.方法重写与重载
  重写(Override)
  重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
  重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
  重载(Overload)
  重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
  每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
  最常用的地方就是构造器的重载。
  方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
  12.抽象类 接口
  抽象类：
  包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。
  抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
  抽象类不能用来创建对象；
  如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
  接口
  接口声明
  关键字：interface ? ? ??public interface ?接口名 {}
  接口体
  常量（没有变量） ?( public static final ) int MAX = 100; ? ? 可以省略public static final
  抽象方法 (public abstract) void add(); 可以省略public abstract
  常量和抽象方法都只有一种访问修饰符：public
  接口默认提供 ?public，static，final，abstract 关键字
  接口的实现
  关键字：implements
  接口中定义的常量，在继承了接口的类中可以直接使用。?
  抽象类 接口的区别
  1.抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
  2.抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
  3.接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
  4.一个类只能继承一个抽象类，而一个类却可以实现多个接口。
  13.访问控制权限4种
  1.访问控制权限有：
  public? 公开的
  protected? 受保护的
  private? ?私有的
  default?? 默认
  2.private：表示私有的，只能在本类中访问。
  ? public：表示公开的，在任何位置都可以访问。
  ? default：表示只能在本类，以及同包下访问。
  ? protected：表示只能在本类、同包、子类中访问。
  范围从大到小排序：public>protected>default>private
  3.访问控制权限修饰符还可以修饰：属性、方法、类(public和default，其他不行)、接口(public和default能用，其他不行 )
  14.多线程
  线程（thread）
  是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以开启多个线程。
  多线程扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。
  简而言之，一个程序运行后至少一个进程，一个进程里包含多个线程。
  如果一个进程只有一个线程，这种程序被称为单线程。
  如果一个进程中有多条执行路径被称为多线程程序。
  一个操作系统中可以有多个进程，一个进程中可以有多个线程，每个进程有自己独立的内存，每个线程共享一个进程中的内存，每个线程又有自己独立的内存
  线程生命周期，总共有五种状态：

1. 新建状态（New）：
   当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()；
2. 就绪状态（Runnable）：
   当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
3. 运行状态（Running）：
   当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
4. 阻塞状态（Blocked）：
   处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态；
5. 根据阻塞产生的原因不同，阻塞状态又可以分为三种：
   a) 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
   b) 同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
   c) 其他阻塞：
   通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
6. 死亡状态（Dead）：
   线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
   多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的
   把有可能出现问题的代码包起来，一次只让一个线程执行。通过sychronized关键字实现同步。
   当多个对象操作共享数据时，可以使用同步锁解决线程安全问题。 synchronized
   15.集合
   集合：集合是java中提供的一种容器，可以用来存储多个数据。
   Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。
   List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，
   Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。
   Collection 常用功能
   　　Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：
   public boolean add(E e)： 把给定的对象添加到当前集合中 。
   public void clear() :清空集合中所有的元素。
   public boolean remove(E e): 把给定的对象在当前集合中删除。
   public boolean contains(E e): 判断当前集合中是否包含给定的对象。
   public boolean isEmpty(): 判断当前集合是否为空。
   public int size(): 返回集合中元素的个数。
   public Object[] toArray(): 把集合中的元素，存储到数组中
   Iterator接口
   　　JDK专门提供了一个接口java.util.Iterator，遍历集合中的所有元素。
   　　Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，
   　　Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
   　　想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，获取迭代器的方法：
   public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
   　　Iterator接口的常用方法如下：
   public E next():返回迭代的下一个元素。
   public boolean hasNext():如果仍有元素可以迭代，则返回 true。
   集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。
   　　泛型：可以在类或方法中预支地使用未知的类型。一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
   16.IO流
   Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。
   字节流
   InputStream
   InputStream：字节输入流基类，抽象类是表示字节输入流的所有类的超类
   OutputStream
   OutputStream：字节输出流基类，抽象类是表示输出字节流的所有类的超类。
   字节文件操作流
   FileInputStream
   FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流
   FileOutputStream
   FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。
   字节缓冲流（高效流）
   BufferedInputStream
   BufferedInputStream：字节缓冲输入流，提高了读取效率。
   BufferedOutputStream
   BufferedOutputStream：字节缓冲输出流，提高了写出效率。
   字符流
   Reader
   Reader:读取字符流的抽象类.
   Writer
   Writer:写入字符流的抽象类
   字符转换流
   InputStreamReader
   InputStreamReader：字节流转字符流，它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
   OutputStreamWriter
   OutputStreamWriter：字节流转字符流。
   字符缓冲流（高效流）
   BufferedReader
   BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
   BufferedWriter
   BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
   17.什么是数据库?
   数据库是数据管理的有效技术，是由一批数据构成的有序集合，这些数据被存放在结构化的数据表里。数据表之间相互关联，反映客观事物间的本质联系。数据库能有效地帮助一个组织或企业科学地管理各类信息资源。
   数据是数据库中存储的基本对象，是按一定顺序排列组合的物理符号。数据有多种表现形式，可以是数字、文字、图像，甚至是音频或视频，它们都可以经过数字化后存入计算机。
   数据库是数据的集合，具有统一的结构形式并存放于统一的存储介质内，是多种应用数据的集成，并可被各个应用程序所共享
   18.mysql数据类型有哪些？
   MySQL支持多种类型，大致可以分为四类：数值型、浮点型、日期/时间和字符串(字符)类型。
   1、数值类型
   　　MySQL支持所有标准SQL数值数据类型。
   　　这些数值类型包括严格数值数据类型(INTEGER、SMALLINT、DECIMAL和NUMERIC)，以及近似数值数据类型(FLOAT、REAL和DOUBLE PRECISION)。
   　　关键字INT是INTEGER的同义词，关键字DEC是DECIMAL的同义词。
   2、 浮点型 float double
   3.日期和时间类型
   　　表示时间值的日期和时间类型为DATETIME、DATE、TIMESTAMP、TIME和YEAR。
   　　每个时间类型有一个有效值范围和一个"零"值，当指定不合法的MySQL不能表示的值时使用"零"值。
   4 字符串类型
   　　字符串类型指CHAR、VARCHAR、BINARY、VARBINARY、BLOB、TEXT、ENUM和SET。
   19.mysql的约束有哪些？
   1、非空约束(not null)
   非空约束用于确保当前列的值不为空值，非空约束只能出现在表对象的列上。Null类型特征：所有的类型的值都可以是null，包括int、float 等数据类型
   2、唯一性约束(unique)
   唯一约束是指定table的列或列组合不能重复，保证数据的唯一性。唯一约束不允许出现重复的值，但是可以为多个null。同一个表可以有多个唯一约束，多个列组合的约束。在创建唯一约束时，如果不给唯一约束名称，就默认和列名相同。唯一约束不仅可以在一个表内创建，而且可以同时多表创建组合唯一约束。
   3、主键约束(primary key)
   PK主键约束相当于 唯一约束 + 非空约束 的组合，主键约束列不允许重复，也不允许出现空值。每个表最多只允许一个主键，建立主键约束可以在列级别创建，也可以在表级别创建。当创建主键的约束时，系统默认会在所在的列和列组合上建立对应的唯一索引。
   4、外键约束(foreign key)
   FK外键约束是用来加强两个表（主表和从表）的一列或多列数据之间的连接的，可以保证一个或两个表之间的参照完整性，外键是构建于一个表的两个字段或是两个表的两个字段之间的参照关系。创建外键约束的顺序是先定义主表的主键，然后定义从表的外键。也就是说只有主表的主键才能被从表用来作为外键使用，被约束的从表中的列可以不是主键，主表限制了从表更新和插入的操作。
   5、默认值约束 (Default)
   若在表中定义了默认值约束，用户在插入新的数据行时，如果该行没有指定数据，那么系统将默认值赋给该列，如果我们不设置默认值，系统默认为NULL。
   6、自增约束(AUTO_INCREMENT)
   自增约束(AUTO_INCREMENT)可以约束任何一个字段，该字段不一定是PRIMARYKEY字段，也就是说自增的字段并不等于主键字段。 但是PRIMARY_KEY约束的主键字段，一定是自增字段，即PRIMARY_KEY 要与AUTO_INCREMENT一起作用于同一个字段。当插入第一条记录时，自增字段没有给定一个具体值，可以写成DEFAULT/NULL，那么以后插入字段的时候，该自增字段就是从1开始，没插入一条记录，该自增字段的值增加1。当插入第一条记录时，给自增字段一个具体值，那么以后插入的记录在此自增字段上的值，就在第一条记录该自增字段的值的基础上每次增加1。
   20.什么是事务？事物的特点？事物的作用？
   事务是应用程序中一系列严密du的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。
   事务具有四个特征：原子性（ Atomicity ）、一致性（ Consistency ）、隔离性（Isolation ）和持续性（ Durability ）。
   事务是为了保证对同一数据表操作的一致性。即多条语句放在事务中执行的时候，要么一起成功，要么全不成功。
   21.什么是JDBC？
   JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序，同时，JDBC也是个商标名。
   22.JDBC连接数据库的过程？
   1.注册数据库驱动
   2.获取数据库连接
   3.获取传输器
   4.发送sql语句到服务器运行，并返回运行结果
   5.处理结果
   6.释放资源
   23.如何防止sql注入攻击？
   SQL注入攻击产生的原因: 由于后台执行的SQL语句是拼接而来的：其中的参数是用户提交过来的，如果用户在提交参数时，在参数中掺杂了一些SQL关键字（比如or）或者特殊符号（#、-- 、’ 等），就可能会导致SQL语句语义的变化，从而执行一些意外的操作（用户名或密码不正确也能登录成功）
   如何防止SQL注入攻击？
   (1)使用正则表达式对用户提交的参数进行校验。如果参数中有（# – ’ or等）这些符号就直接结束程序，通知用户输入的参数不合法
   (2)使用PreparedStatement对象来替代Statement对象。
   24.什么是连接池？使用连接池的好处？
   连接池：
   就是将连接存放在容器中，供整个程序共享，可以实现连接的复用，减少连接创建和关闭的次数，从而提高程序执行的效率！在传统方式中，每次用户需要连接访问数据库时，都是创建一个连接对象，基于这个连接对象访问数据库，用完连接后，会将连接关闭（conn.close）由于每次创建连接和关闭连接非常的耗时间而且耗资源，因此会导致程序执行的效率低下。
   好处：
   可以在程序一启动时，就创建一批连接放在一个连接池中（容器），当用户需要连接时，就从连接池中获取一个连接对象，用完连接后，不要关闭，而是将连接再还回连接池中，这样一来，用来用去都是池中的这一批连接，实现了连接的复用，减少了连接创建和关闭的次数，从而提高了程序执行的效率！
   25.什么是HTML？
   HTML(Hyper Text Markup Language): 超文本标记语言；是最基础的开发网页的语言。由W3C组织提供(CSS/xml)
   26.html的结构是什么样的？
   (1)
   文档声明, 用来声明HTML文档所遵循的HTML规范和版本
   上面是html5.0的声明, 也是目前最常用的版本
   (2)
   头部分, 用来存放HTML文档的基本属性信息, 比如网页的标题, 文档使用的编码等, 这部分信息会被浏览器优先加载.
   (3)
   体部分, 用来存放网页可视化数据. 即真正的网页数据
   (4)
   声明网页的标题
   (5)
   用来通知浏览器使用哪一个编码来打开HTML文档, 这个编码一定要和文件保存时的编码保持一致, 才不会出现中文乱码问题.
   27.什么是HTML的标签和属性？
   标签：也叫做标记、元素等，标签分为开始标签和结束标签
   在标签上可以声明属性，标签上可以声明多个属性，多个属性之间用空格分隔
   标签上的属性的值可以使用单引号或者双引号引起来
   如何在网页中做一个换行：可以使用
   标签做换行
   如何在网页中做一个空格：可以使用 或 做空格
   28.什么是超链接？有哪些属性？
   
   
   
   其中 href 属性用于指定点击超链接后将要跳转到的URL地址
   target属性用于指定以何种方式打开超链接
   _self：默认值, 表示在当前窗口中打开超链接
   _blank：表示在新的窗口中打开超链接
   29.表单一般包含哪些元素？

表单项标签： 30.什么是css? CSS: 层叠样式表，用于修饰、渲染网页的一门技术 使用css样式修饰网页，可以实现将设置样式的css代码和展示数据的html代码进行分离，增强了网页的展示能力！ 31.在HTML中引入css的方式有几种？优先级 方式1：通过style属性引入css（不推荐）

我们只需要修改这里面的8080端口号为指定的端口号就行，其他的都不需要改： 例如： 改完后一定要重启服务器。 42、什么是Http协议？Http协议在工作时遵循什么原则？ Http协议： • HTTP协议是用于规定浏览器和服务器之间的通信方式/规则 • 主要规定了浏览器给服务器发送的请求信息的格式 • 以及规定了服务器给浏览器发送响应信息的格式 遵循原则： （1）一次请求，只对应一次响应 （2）请求只能由浏览器发起，服务器只能被动的等待请求，根据请求作出回应。 43、请求方式GET和POST 的区别？ 主要区别体现在请求参数传输过程的不相同 1. GET提交： • 将数据通过问号拼接在地址栏URL地址的后面，相对非常不安全。 • 将数据拼接在地址栏URL地址的后面，数据量是有限制的，通常不能超过1KB或者4KB。 2. POST提交：（form） • POST提交是通过请求实体将数据提交给服务器，不会显示在地址栏上，因此相对更加安全。 • POST提交通过请求实体提交数据，数据量理论上是没有限制的。 3. 总结： • 如果只是单纯做一个跳转，请求中没有数据，尽量使用GET提交。 • 如果在请求中有数据，但数据量不大，并且数据没有隐私性，也尽量使用GET提交。 • 如果在请求中有数据，数据量比较大或者数据较为隐私，此时推荐使用POST提交。 • 只有当使用表单（form），并且在表单上明确的通过method指定提交方式为POST时，请求方式才是POST提交，其他方式都是GET提交（AJAX除外） 44、什么是Servlet?Servlet的作用是什么？ Servlet： Servlet是由SUN公司提供的一门动态Web资源开发技术， 静态Web资源：不同的人，在不同的条件下访问后看到的是相同的效果，这样的资源叫做静态Web资源（html、css、js等） 动态Web资源：在不同的访问条件下看到的是不同的效果，这样的资源叫做动态Web资源 （Servlet、jsp、.NET、PHP等） Servlet本质上是一段Java程序，和之前的Java程序不同的是，Servlet程序无法独立运行，需要将Servlet程序放在服务器中（比如tomcat服务器），由服务器调用才可以执行。 Servlet: 服务器端的Java程序. 作用： 其作用是对服务器接收过来的请求进行处理（作用为处理请求）

45、如何开发一个Servlet程序？
开发Servlet程序的步骤
第一步: 写一个类，实现一个Servlet接口或者继承Servlet接口的子类（GenericServlet/HttpServlet），并实现其中的方法
Servlet接口
|-- GenericServlet类(抽象类)
|-- HttpServlet类
第二步: 在web应用的web.xml文件中配置Servlet程序对外访问的路径。
Eclipse在创建一个Servlet时，会在web.xml文件中生成Servlet配置，所以不需要我们手动配置。

1. 创建一个Web工程:

2、接着会弹出如下窗口:

注意：
(1) 3.0版本不会创建web.xml文件,并且创建Servlet时也不会在web.xml文件中生成Servlet相关的配置信息, 记得改为2.5。
(2) Target runtime选项中如果没有可选的服务器，可点击右侧的"NewRuntime…"进行配置。
3、Eclipse中创建的Web工程的目录结构：
(1) day09: 工程名称/项目名称
(2) src: 源码目录, 创建的java源文件、配置文件（properties、xml文件等）都可以放在src源码目录下
(3) build/classes: 编译文件的输出目录, src源码目录中的文件编译后会输出到classes目录下。
其中的classes目录在发布时会放在WEB-INF目录下，随着项目一起发布到服务器中
(4) WebContent: 就是Web应用的目录，其中可以存放 html、css、js、jsp、图片以及编译后的class文件、jar包、web.xml文件等. 将来发布项目到服务器，其实就是将WebContent中的所有内容一起发布到服务器中。
(5) WebContent/WEB-INF/lib: 用于存放当前项目所依赖的jar包。比如要访问mysql数据库，需要导入mysql驱动包，直接将jar包拷贝到lib目录下即可！（也不用再去做 build path --> add to build path）
使用Eclipse创建Servlet
1、选中项目中的src目录，鼠标右键 —> New —> Servlet
2、在弹出的窗口中，根据提示填写内容

3、点击finish即可完成Servlet创建过程, 创建好的Servlet如下:

通过Eclipse创建Servlet，默认继承HttpServlet。由于HttpServlet也是Servlet接口的子类，让HelloServlet继承HttpServlet，相当于间接实现了Servlet接口。
继承HttpServlet类，默认会覆盖doGet方法和doPost方法，两个方法的作用为：

• doGet方法：当浏览器发送请求的方式为GET提交时, 将会调用doGet方法来处理请求
• doPost方法：当浏览器发送请求的方式为POST提交时,将会调用doPost方法来处理请求
  提示：如果当GET提交和POST提交处理代码相同时，可以将代码写在其中一个方法里（例如写在doGet中），并在另外一个方法（例如doPost）中调这个方法。这样一来,不管是GET提交还是POST提交,最终doGet方法都会执行,都会对请求进行处理!!
  Servlet在web.xml中的配置
  
  HelloServlet
  com.tedu.HelloServlet
  
  
  HelloServlet
  /HelloServlet
  
  关于上面的配置信息：
  a) Eclipse每创建一个Servlet，就会在web.xml文件中添加两个标签：和标签（可以将这两个标签看成一个组的标签）
  b) 和标签内都会有一个标签，标签的内容可以更改，但要求更改后的这两个标签的内容也必须一致。
  c) 标签用于配置Servlet类的全限定类名(即包名+类名)
  需要注意：如果在创建Servlet后修改了Servlet类的名称，这个地方也要一起更改，否则将会出现"ClassNotFoundException" 即类找不到异常
  d) 标签用于配置浏览器以什么路径访问当前Servlet（即Servlet对外访问的路径），默认的路径是：/类名
  例如：上面为HelloServlet配置的为/HelloServlet，因此我们在浏览器中的访问路径则为：
  http://主机名/web项目访问路径/HelloServlet
  运行Servlet程序、访问测试

若是第一次运行，需要先创建tomcat服务器，即在Servers窗口中点击链接可创建一个tomcat服务器，且只需创建一次即可！
(1)发布项目到服务器：在服务器上右键 --> 点击 “add and remove” 将当前web项目发布到服务器中，并点击完成。
(2)启动tomcat服务器：在服务器上右键 Start 即可启动服务器
(3)通过浏览器访问Servlet：打开本地浏览器，通过路径访问，即可访问Servlet程序
http://localhost:端口/项目名称/HelloServlet
运行结果如下：

46、Servlet生命周期是什么？
生命周期：
在服务器调用Servlet程序的service方法之前，会创建代表请求的request对象，在请求处理完，响应结束时，会销毁request对象。
47、Servlet数据传递的范围有几种？分别是什么？
一、servlet的三种转发方式
1、req.getRequestDispatcher(url).forward(req,resp);
将req和resp转发给url表示的对象 由于是转发地址栏中的地址不变
2、req.getRequestDispatcher(url).include(req,resp);
将req和resp转发给url表示的对象，同时发送PrintWriter在此处写入的信息（但是这里注意写入信息要在这一句之前写入，否则resp已经被转发就不能在写入了） 同样由于是转发地址栏中的地址不便
3、resp.sendRedirect(url);
请求客户端重新定向与url再次发送req 由于是重新定位发送，地址栏中的地址改变
url可以是html 可以是jsp 也可以是servlet
二、servlet对象中数据的范围
这三个对象是ServletRequest Session ServletContext
他们都一致用setAttribute(String key,Object value)
getAttribute(String key)
removeAttribute(String key)
来存放和取出数据。 不同之处在与他们的作用范围不同
1、ServletRequest
作用范围最小的一个，消耗资源少，用的相对比较多。
通过不同servlet间转发传递ServRequest来传递数据。
2、Session
通过ServletRequest的getSession方法得到。
从session第一次创建直到Session因超时或客户端关闭之前，数据会一直存在。
Session 常用做存入某个用户相关的数据对象。
3、ServletContext
通过Servlet的getServletConext方法得到。
作用范围最大的一个。只要服务器中建立了它，他就一直存在。直到服务器关闭。
48、什么是Cookie和Session？
Cookie

1. Cookie是将会话中产生的数据保存在客户端，是客户端技术。
2. Cookie是基于两个头进行工作的：分别是Set-Cookie响应头和Cookie请求头
3. 通过Set-Cookie响应头将cookie从服务器端发送给浏览器，让浏览器保存到内部；而浏览器一旦保存了cookie，以后浏览器每次访问服务器时，都会通过cookie请求头，将cookie信息再带回服务器中。在需要时，在服务器端可以获取请求中的cookie中的数据，从而实现某些功能。
   cookie的API

Session

1. Session是将会话中产生的数据保存在服务器端，是服务器端技术
2. Session是一个域对象，session中也保存了一个map集合，往session中存数据，其实就是将数据保存到session的map集合中。
3. 通过session.setAttribute()方法可以将数据保存到session中，通过session.getAttribute()方法可以将数据从session中取出来。
   session是一个域对象
   总结:两者的区别
   Cookie和session都属于会话技术，都可以保存会话中产生的数据，但由于cookie和session的工作原理和特点不同，因此两者的应用场景也不一样。
   • Cookie的特点：
4. cookie是将会话中产生的数据保存在浏览器客户端, 是客户端技术（JS可以访问cookie）
5. cookie是将数据保存在客户端浏览器，容易随着用户的操作导致cookie丢失或者被窃取，因此cookie中保存的数据不太稳定，也不太安全。
6. 但cookie将数据保存在客户端，对服务器端没有太多影响，可以将数据保存很长时间。
7. 总结：因此cookie中适合存储需要长时间保存、但对安全性要求不高的数据。
8. 浏览器对cookie的大小和个数都有限制，一般推荐每一个站点给浏览器发送的cookie数量不超过20个，每一个cookie的大小不超过1kb。
9. Cookie的应用：实现购物车、记住用户名、30天内自动登录等。
   • Session的特点
10. session是将会话中产生的数据保存在服务器端，是服务器端技术
11. session将数据存在服务器端的session对象中，相对更加的安全，而且更加稳定。不容易随着用户的操作而导致session中的数据丢失或者是被窃取。
12. 但session是服务器端的对象，在并发量较高时每一个浏览器客户端在服务器端都要对应一个session对象，占用服务器的内存空间，影响效率。
13. 总结：因此session中适合存储对安全性要求较高，但不需要长时间保存的数据。
14. Session的应用：保存登录状态、保存验证码
    49、转发和重定向的区别？
    转发：
    定义：
    请求转发是服务器内部资源的一种跳转方式，即当浏览器发送请求访问服务器中的某一个资源（A）时，该资源将请求转交给另外一个资源（B）进行处理并且由资源B做出响应的过程，就叫做请求转发。
    特点：
    1）转发是一次请求，一次响应
    （2）请求转发前后，浏览器的地址栏地址不会发生变化。（浏览器–访问–> A --转发–> B，地址栏地址始终指向A的地址）
    （3）请求转发前后的request对象是同一个（转发前在A中的request和转发到B后，B中的request对象和A中的request对象是同一个。基于这一点，可以通过request从A带数据到B）
    （4）请求转发前后的两个资源必须属于同一个Web应用，否则将无法进行转发。（A–转发–>B，A和B必须属于同一个Web应用！）
    重定向：
    定义：
    当浏览器向服务器发请求访问某一个资源A，资源A在响应时通知浏览器需要再进一步请求才能获取到对应的资源，浏览器再次发请求访问服务器中的资源B，最终由资源B响应浏览器要获取的资源，这个过程叫做重定向。
    特点：
    （1）重定向是两次请求、两次响应
    （2）重定向前后，浏览器的地址栏地址会发生变化。（因为两次请求都是通过浏览器发起，浏览器知道这个跳转的过程，因此地址栏地址会变化）
    （3）重定向前后的request对象不是同一个（因为重定向是两次请求，服务器会根据两次请求创建两个不同的request对象，request对象不是同一个，也就不能在重定向时通过request带数据到目的地。）
    （4）重定向前后的两个资源可以是来自不同的web应用，甚至可以是来自不同的服务器。(进行跳转的两个资源之间没有限制)
    用处：
    (1)如果希望跳转前后地址栏地址不会发生变化, 只能使用转发; 如果希望跳转前后地址栏地址会发生变化, 只能使用重定向
    (2)如果希望在跳转前后, 能够通过request对象带数据到目的地, 只能使用转发
    (3)如果仅仅是做一个跳转,没有其他要求,此时推荐使用转发(转发是一次请求,一次响应,可以减少访问服务器的次数,降低服务器的压力)
    50、什么是jsp？
    • JSP和Servlet都是由SUN公司提供的动态Web资源开发技术
    • JSP看起来像一个HTML，但和HTML不同的是，JSP中可以书写Java代码，可以通过Java代码展示动态的数据。
    • JSP本质上是一个Servlet程序
    在JSP第一次被访问时，会翻译成一个Servlet程序。访问JSP后看到的html网页，其实是翻译后的Servlet执行的结果。（也就是说，访问JSP后看到的网页，是JSP翻译后的Servlet输出到浏览器的。）
    51、jsp有多少内置对象，分别说明？
    序号 内置对象 对应 Servlet 类 作用
    1 request javax.servlet.http.HttpServletRequest 客户端的请求信息：Http协议头信息、Cookie、请求参数等
    2 response javax.servlet.http.HttpServletResponse 用于服务端响应客户端请求，返回信息
    3 pageContext javax.servlet.jsp.PageContext 页面的上下文
    4 session javax.servlet.http.HttpSession 客户端与服务端之间的会话
    5 application javax.servlet.ServletContext 用于获取服务端应用生命周期的信息
    6 out javax.servlet.jsp.JspWriter 用于服务端传输内容到客户端的输出流
    7 config javax.servlet.ServletConfig 初始化时，Jsp 引擎向 Jsp 页面传递的信息
    8 page java.lang.Object 指向 Jsp 页面本身
    9 exception java.lang.Throwable 页面发生异常，产生的异常对象
    JSP提供了由容器实现和管理的内置对象，也可以称之为隐含对象，由于JSP使用Java作为脚本语言，所以JSP将具有强大的对象处理能力，并且可以动态创建Web页面内容。但Java语法在使用一个对象前，需要先实例化这个对象，这其实是一件比较烦琐的事情。JSP为了简化开发，提供了一些内置对象，用来实现很多JSP应用。在使用JSP内置对象时，不需要先定义这些对象，直接使用即可。
    在JSP中一共预先定义了9个这样的对象，分别为request、response、session、application、out、pageContext、config、page和exception。
    1、request对象
    request对象封装了由客户端生成的HTTP请求的所有细节，主要包括HTTP头信息、系统信息、请求方式和请求参数等。通过request对象提供的相应方法可以处理客户端浏览器提交的HTTP请求中的各项参数。
    request对象的常用方法：

1.1 访问请求参数
我们知道request对象用于处理HTTP请求中的各项参数。在这些参数中，最常用的就是获取访问请求参数。当我们通过超链接的形式发送请求时，可以为该请求传递参数，这可以通过在超链接的后面加上问号“?”来实现。注意这个问号为英文半角的符号。
如果要同时指定多个参数，各参数间使用与符号“&”分隔即可。
示例：在页面中定义超链接。
删除
在delete.jsp页面中，可以通过request对象的getParameter()方法获取传递的参数值。
<%
String id = request.getParameter(“id”); //获取id参数的值
%>
示例：编程学员注册功能。要求提交注册信息后，显示学员输入的数据。
（1）注册页面 reginput.jsp。
<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>

学员注册

请输入注册信息

用户姓名：
博客地址：
备注信息：
兴趣爱好：	足球 篮球 羽毛球 乒乓球

（2）注册提交页面 reginfo.jsp。 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <% request.setCharacterEncoding("UTF-8"); //设置请求编码 String name = request.getParameter("name"); //获取用户名 String blog = request.getParameter("blog"); //获取博客地址 String remark = request.getParameter("remark"); //获取备注信息 //获取兴趣爱好 String[] interests = request.getParameterValues("interests"); String interStr = ""; if(interests != null) { for(String item : interests) { interStr += item + ";"; } } %> 注册信息 用户姓名：<%= name %>
博客地址：<%= blog %>
备注信息：<%= remark %>
兴趣爱好：<%= interStr %> 执行结果： （1）注册页面 reginput.jsp

（2）注册提交页面 reginfo.jsp

1.2 在作用域中管理属性
在进行请求转发时，需要把一些数据传递到转发后的页面进行处理。这时，就需要使用request对象的setAttribute()方法将数据保存到request范围内的变量中。request对象的setAttribute()方法的语法格式如下：
request.setAttribute(String name,Object object);
在将数据保存到request范围内的变量中后，可以通过request对象的getAttribute()方法获取该变量的值，具体的语法格式如下：
request.getAttribute(String name)
1.3 获取cookie
cookie的中文意思是小甜饼，然而在互联网上的意思与这就完全不同了。它和食品完全没有关系。在互联网中，cookie是小段的文本信息，在网络服务器上生成，并发送给浏览器的。通过使用cookie可以标识用户身份，记录用户名和密码，跟踪重复用户等。浏览器将cookie以key/value的形式保存到客户机的某个指定目录中。
通过cookie的getCookies()方法即可获取到所有cookie对象的集合；通过cookie对象的getName()方法可以获取到指定名称的cookie；通过getValue()方法即可获取到cookie对象的值。另外将一个cookie对象发送到客户端使用了response对象的addCookie()方法。
示例：通过cookie保存用户信息。
（1）写入cookie对象页面 index.jsp。
<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>

写入cookie对象 <% //写入cookie对象 request.setCharacterEncoding("UTF-8"); //设置请求的编码 Cookie cookie = new Cookie("userCookie","您好，欢迎访问pan_junbiao的博客！"); //创建并实例化cookie对象 cookie.setMaxAge(60*60*24*30); //设置cookie有效期为30天 response.addCookie(cookie); //保存cookie对象 %>

（2）读取cookie值页面 deal.jsp。
<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>

读取cookie值 <% //读取cookie值 Cookie[] cookies = request.getCookies(); //从request中获取cookie对象的集合 String user = ""; if(cookies != null) { //遍历cookie对象集合 for(Cookie cookieItem : cookies) { if(cookieItem.getName().equals("userCookie")) { user = cookieItem.getValue(); //读取cookie对象的的值 } } } %>

读取cookie值:

用户信息：<%= user %> 执行结果：

1.4 解决中文乱码
在上面的代码中我们为id参数传递了一个字符串类型的值“001”，如果将这个参数的值更改为中文，则在show.jsp就会发生大家都不愿意看到的问题——在显示参数值时中文内容变成了乱码。这是因为请求参数的文字编码方式与页面中的不一致所造成的，所有的request请求都是iso-8859-1的，而在此页面采用的是UTF-8的编码方式。要解决此问题，只要将获取到的数据通过String的构造方法使用指定的编码类型重新构造一个String对象即可正确地显示出中文信息。

解决中文乱码 name参数的值为：<%=new String(request.getParameter("name").getBytes("iso-8859-1"),"UTF-8") %>
sex参数的值为：<%=request.getParameter("sex") %> 1.5 获取客户端信息 通过request对象可以获取客户端的相关信息，如HTTP报头信息，客户信息提交方式、客户端主机IP地址、端口号等。 request获取客户端信息的常用方法： 示例：使用request对象的相关方法获取客户端信息。

<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>

使用request对象的相关方法获取客户端信息 客户提交信息的方式：<%=request.getMethod()%>
使用的协议：<%=request.getProtocol()%>
获取发出请求字符串的客户端地址：<%=request.getRequestURI()%>
获取发出请求字符串的客户端地址：<%=request.getRequestURL()%>
获取提交数据的客户端IP地址：<%=request.getRemoteAddr()%>
获取服务器端口号：<%=request.getServerPort()%>
获取服务器的名称：<%=request.getServerName()%>
获取客户端的主机名：<%=request.getRemoteHost()%>
获取客户端所请求的脚本文件的文件路径:<%=request.getServletPath()%>
获得Http协议定义的文件头信息Host的值:<%=request.getHeader("host")%>
获得Http协议定义的文件头信息User-Agent的值:<%=request.getHeader("user-agent")%>
获得Http协议定义的文件头信息accept-language的值:<%=request.getHeader("accept-language")%>
获得请求文件的绝对路径:<%=request.getRealPath("index.jsp")%> 执行结果：

1.6 显示国际化信息
浏览器可以通过accept-language的HTTP报头向Web服务器指明它所使用的本地语言。request对象中的getLocale()和getLocales()方法允许JSP开发人员获取这一信息，获取的信息属于java.util.Local类型。java.util.Local类型的对象封装了一个国家和一种国家所使用的语言。使用这一信息，JSP开发者就可以使用语言所特有的信息作出响应。
示例：页面信息国际化。
<%
java.util.Locale locale = request.getLocale();
String str = “”;
if(locale.equals(java.util.Locale.US))
{
str = “Hello, Welcome to pan_junbiao’s blog!”;
}
else if(locale.equals(java.util.Locale.CHINA))
{
str = “您好，欢迎访问 pan_junbiao的博客！”;
}
%>

<%= str %>

2、response对象
response对象用于响应客户请求，向客户端输出信息。它封装了JSP产生的响应，并发送到客户端以响应客户端的请求。请求的数据可以是各种数据类型，甚至是文件。response对象在JSP页面内有效。
request对象的常用方法：
sendRedirect(String path) 将网页重定向到另一个页面。
setHeader(String name, String value) 设置HTTP响应报头信息。
2.1 重定向网页
使用response对象提供的sendRedirect()方法可以将网页重定向到另一个页面。重定向操作支持将地址重定向到不同的主机上，这一点与转发不同。在客户端浏览器上将会得到跳转的地址，并重新发送请求链接。用户可以从浏览器的地址栏中看到跳转后的地址。进行重定向操作后，request中的属性全部失效，并且开始一个新的request对象。sendRedirect()方法的语法格式如下：
response.sendRedirect(String path);
参数说明：
path：用于指定目标路径，可以是相对路径，也可以是不同主机的其他URL地址。
示例：使用response对象提供的sendRedirect()方法重定向到登录页面。
<%
response.sendRedirect(“login.jsp”); //重定向到登录页面
%>
2.2 处理HTTP文件头
通过response对象可以设置HTTP响应报头，其中，最常用的是禁用缓存、设置页面自动刷新和定时跳转网页。下面分别进行介绍。
设置HTTP响应报头方法的语法格式如下：
response.setHeader(String name, String value);
2.2.1 禁用缓存
在默认情况下，浏览器将会对显示的网页内容进行缓存，这样可以提高网页的显示速度。对于一些安全性要求比较高的网站，通常需要禁用缓存。
示例：通过设置HTTP头的方式实现禁用缓存。
<%
response.setHeader(“Cache-Control”, “no-store”);
response.setDateHeader(“Expires”, 0);
%>
2.2.2 设置页面自动刷新
通过设置HTTP头还可以实现页面的自动刷新。
示例：使页面每隔10秒自动刷新一次。
<%
response.setHeader(“refresh”, “10”);
%>
2.2.3 定时跳转网页
通过设置HTTP头还可以实现定时跳转页面功能。
示例：使页面5秒后自动跳转到指定的网页。
<%
response.setHeader(“refresh”, “5;URL=login.jsp”);
%>
2.3 设置输出缓冲
通常情况下，服务器要输出到客户端的内容不会直接写到客户端，而是先写到一个输出缓冲区，在计算机术语中，缓冲区被定义为暂时放置输入或输出资料的内存。实际上，缓冲区也可以这样理解：在一个粮库中，由于装缷车队的速度要快于传送带的传输速度，为了不造成装缷车队的浪费，粮库设计了一个站台，装缷车队可以先将运送的粮食缷到这个平台上，然后让传送机慢慢传送。粮库的这个站台就起到了缓冲的作用。
response对象提供的对缓冲区进行配置的方法：
flushBuffer() 强制将缓冲区的内容输出到客户端。
getBufferSize() 获取响应所使用的缓冲区的实际大小，如果没有使用缓冲区，则返回0。
setBufferSize(int size) 设置缓冲区大小。
reset() 清除缓冲区的内容，同时清除状态码和报头。
isCommitted() 检查服务器端是否已经把数据写入到可客户端。
示例：设置缓冲区的大小为32KB。
<%
response.setBufferSize(32);
%>
说明：如果将缓冲区的大小设置为0KB，则表示不缓冲。

3、session对象
session在网络中被称为会话。由于HTTP协议是一种无状态协议，也就是当一个客户向服务器发出请求，服务器接收请求，并返回响应后，该连接就结束了，而服务器并不保存相关的信息。为了弥补这一缺点，HTTP协议提供了session。通过session可以在应用程序的Web页面间进行跳转时，保存用户的状态，使整个用户会话一直存在下去，直到关闭浏览器。但是，如果在一个会话中，客户端长时间不向服务器发出请求，session对象就会自动消失。这个时间取决于服务器，例如，Tomcat服务器默认为30分钟。不过这个时间可以通过编写程序进行修改。
session对象的常用方法：
示例：保存与获取session对象信息。

<%
session.setAttribute(“UserName”, “pan_junbiao的博客”); //保存session对象
String userName = session.getAttribute(“UserName”).toString(); //获取session对象
%>
配置web.xml文件：
如果使用的是Tomcat，可以向下面这样配置web.xml文件：

15

超时以分钟为单位，Tomcat中的默认的超时时间是30分钟。
Servlet中的getMaxInactiveInterval( ) 方法以秒为单位返回超时时间。如果在web.xml中配置的是15分钟，则getMaxInactiveInterval( ) 方法将会返回900。

4、application对象
application对象用于保存所有应用中的共有数据。它在服务器启动时自动创建，在服务器停止时销毁。当application对象没有被销毁时，所有用户都可以共享该application对象。与session对象相比，application对象的生命周期更长，类似于系统的“全局变量”。
application对象的常用方法：
String getInitParameter(String name) 获取已命名的应用程序初始化参数值。
Enumeration getInitParameterNames() 获取所有已定义的应用程序初始化参数名的枚举。
Enumeration getAttributeNames() 获取所有application对象使用的属性名。
Object getAttribute(String name) 从application对象中获取指定对象名。
void setAttribute(String key,Object obj) 使用指定名称和指定对象在application对象中进行关联。
void removeAttribute(String name) 从application对象中去掉指定名称的属性。
4.1 访问应用程序初始化参数
application对象提供了对应用程序初始化参数进行访问的方法。应用程序初始化参数在web.xml文件中进行设置，web.xml文件位于Web应用所在目录下的WEB-INF子目录中。在web.xml文件中通过标记配置应用程序初始化参数。
示例：在web.xml文件中配置连接MySQL数据库所需的url参数。

url
jdbc:mysql://127.0.0.1:3306/db_database


application对象提供了两种访问应用程序初始化参数的方法。
4.1.1 getInitParameter(String name)方法
String getInitParameter(String name)方法用于获取已命名的应用程序初始化参数值。
示例：获取上面web.xml文件中配置的url参数的值。
<%
String url = application.getInitParameter(“url”);
%>
4.1.2 getInitParameterNames()方法
Enumeration getInitParameterNames()方法获取所有已定义的应用程序初始化参数名的枚举。
示例：使用getInitParameterNames()方法获取web.xml文件中定义的全部应用程序初始化参数，并通过循环输出。
<%@ page import=“java.util.*” %>
<%
Enumeration enume = application.getInitParameterNames(); //获取全部初始化参数
while(enume.hasMoreElements())
{
String name = enume.nextElement(); //获取参数名
String value = application.getInitParameter(name); //获取参数值
out.println(name + “：”); //输出参数名
out.println(value); //输出参数值
}
%>
4.2 管理应用程序环境属性
与session对象相同，也可以在application对象中设置属性。与session对象不同的是，session只是在当前客户的会话范围内有效，当超过保存时间，session对象就被收回；而application对象在整个应用区域中都有效。
<%
application.setAttribute(“UserName”, “pan_junbiao的博客”); //保存application对象
String userName = application.getAttribute(“UserName”).toString(); //获取application对象
%>

5、out对象
out对象用于在Web浏览器内输出信息，并且管理应用服务器上的输出缓冲区。在使用out对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出流。
5.1 向客户端输出数据
out对象一个最基本的应用就是向客户端浏览器输出信息。out对象可以输出各种数据类型的数据，在输出非字符串类型的数据时，会自动转换为字符串进行输出。out对象提供了print()和println()两种向页面中输出信息的方法。
5.1.1 print()方法
示例：通过两种方式向客户端浏览器输出文字。
<%
out.print(“您好，pan_junbiao的博客”);
%>

<%= “您好，pan_junbiao的博客” %>
5.1.2 println()方法
println()方法也可以用于向客户端浏览器输出信息，该方法输出内容后，还输出一个换行符。
示例：使用println()方法向客户端浏览器输出文字。

<%
    out.println("使用println()方法向客户端浏览器输出文字：");
    out.println("您好！");
    out.println("欢迎访问 pan_junbiao的博客");
    out.println("博客地址：https://blog.csdn.net/pan_junbiao");
%>

说明：使用println()方法输出内容要有换行的效果，需要同时使用HTML的

标记括起来，否则无法显示换行效果。

执行效果：

5.2 管理响应缓冲
out对象的另一个比较重要的功能就是对缓冲区进行管理。通过调用out对象的clear()方法可以清除缓冲区的内容。这类似于重置响应流，以便重新开始操作。如果响应已经提交，则会有产生IOException异常的负作用。out对象还提供了另一种清除缓冲区内容的方法，那就是clearBuffer()方法，通过该方法可以清除缓冲区的“当前”内容，而且即使内容已经提交给客户端，也能够访问该方法。除了这两个方法外，out对象还提供了其他用于管理缓冲区的方法。
out对象用于管理缓冲区的方法如下：
clear() 清除缓冲区中的内容。
clearBuffer() 清除当前缓冲区中的内容。
flush() 刷新流。
isAutoFlush() 检测当前缓冲区已满时是自动清空，还是抛出异常。
getBufferSize() 获取缓冲区的大小。

6、获取会话范围的pageContext对象
获取页面上下文的pageContext对象是一个比较特殊的对象，通过它可以获取JSP页面的request、response、session、out、exception等对象。pageContext对象的创建和初始化都是由容器来完成的，JSP页面中可以直接使用pageContext对象。
pageContext对象的常用方法：
forward(String relativeUrlPath) 把页面转发给另一个页面。
getAttribute(String name) 获取参数值。
getAttributeNamesInScope(int scope) 获取某范围的参数名称的集合。
getException() 获取exception对象。
getRequest() 获取request对象。
getResponse() 获取response对象。
getSession() 获取session对象。
getOut() 获取out对象。
setAttribute(String name,Object value) 为指定范围内的属性设置属性值。
removeAttribute(String name) 删除指定范围内的指定对象。
说明：pageContext对象在实际JSP开发过程中很少使用，因为request和response等对象均为内置对象，如果通过pageContext对象来调用这些对象比较麻烦。

7、读取web.xml配置信息的config对象
config对象主要用于取得服务器的配置信息。当一个Servlet初始化时，容器把某些信息通过config对象传递给这个Servlet。开发者可以在web.xml文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。
config对象的常用方法如下：
getServletContext() 获取Servlet上下文。
getServletName() 获取Servlet服务器名。
getInitParameter(String name) 获取服务器所有初始化参数名称。
getInitParameterNames() 获取服务器中name参数的初始值。

8、应答或请求的page对象
page对象代表JSP本身，只有在JSP页面内才是合法的。page对象本质上是包含当前Servlet接口引用的变量，可以看作是this关键字的别名。
page对象的常用方法如下：
getClass() 返回当前Object的类。
hashCode() 返回该Object的哈希代码。
toString() 把该Object类转换成字符串。
equals(Object obj) 比较该对象和指定的对象是否相等。
示例：创建index.jsp文件，在该文件中调用page对象的各方法，并显示返回结果。
<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>

page对象各方法的应用 <%! Object object; //声明一个Object型的变量 %>

• getClass()方法的返回值:<%=page.getClass()%>
• hashCode()方法的返回值:<%=page.hashCode()%>
• toString()方法的返回值:<%=page.toString()%>
• 与Object对象比较的返回值:<%=page.equals(object)%>
• 与this对象比较的返回值:<%=page.equals(this)%>

执行结果： 9、获取异常信息的exception对象 exception对象用来处理JSP文件执行时发生的所有错误和异常，只有在page指令中设置 isErrorPage属性值为true的页面中才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。exception对象几乎定义了所有异常情况，在Java程序中，可以使用try...catch关键字来处理异常情况，如果在JSP页面中出现没有捕获到的异常，就会生成exception对象，并把exception对象传送到在page指令中定义的错误页面中，然后在错误页面中处理相应的exception对象。 exception对象的常用方法如下： getMessage() 返回exception对象的异常信息字符串。 getLocalizedMessage() 返回本地化的异常错误。 toString() 返回关于异常错误的简单信息描述。 fillInStackTrace() 重写异常错误的栈行轨迹。 示例：使用exception对象获取异常信息。 （1）创建index.jsp文件，在该文件中，首先在page指令中定义errorPage属性值为error.jsp，即指定显示异常信息的页面。 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" errorPage="error.jsp" %> 使用exception对象获取异常信息 <% request.setAttribute("price", "12.5元"); //保存单价到request范围内的变量price中 float price = Float.parseFloat(request.getAttribute("price").toString()); //获取单价，并转换为float类型 %> （2）编写error.jsp文件，将该页面的page指令的 isErrorPage属性值设置为true，并且输出异常信息。 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" isErrorPage="true" %> 错误提示页面 错误提示为：<%= exception.getMessage() %> 执行结果：

52、Jsp的域对象有哪些？
四大域对象：
（1）pageContext page 域-指当前页面，在当前 jsp 页面有效，跳到其它页面失效
（2）request request 域-指一次请求范围内有效，从 http 请求到服务器处理结束，返回响应的整个过程。在这个过程中使用 forward（请求转发）方式跳转多个 jsp，在这些页面里你都可以使用这个变量
（3）session session 域-指当前会话有效范围，浏览器从打开到关闭过程中，转发、重定向均可以使用
（4）application context 域-指只能在同一个 web 中使用，服务器未关闭或者重启，数据就有效
53、什么是Maven？为什么要用Maven？
Maven: 翻译为"专家"、“内行”，是Apache下的一个纯Java开发的一个开源项目。
Maven是一个项目管理工具，使用Maven可以来管理企业级的Java项目开发及依赖JAr包的管理。
使用Maven开发，可以简化项目配置，统一项目结构。总之，Maven可以让开发者的工作变得更简单。
传统的项目（工程）中管理项目所依赖的jar包完全靠人工进行管理，而人工管理jar包可能会产生诸多问题。
1、不使用Maven，采用传统方式管理jar包的弊端：
(1)在一些大型项目中会使用一些框架，比如SSM或者SSH框架，而框架中所包含的jar包非常多（甚至还依赖其他第三方的jar包），如果这些jar包我们手动去网上寻找，有些jar包不容易找到，比较麻烦。
(2)传统方式会将jar包添加到工程中，比如Java工程中将jar包放在工程根目录或者放在自建的lib目录下；JavaWeb工程会将jar包放在:/WEB-INF/lib目录下，这样会导致项目文件的体积暴增（例如，有些项目代码本身体积可能仅仅几兆，而加入jar包后，工程的体积可能会达到几十兆甚至百兆）。
(3)在传统的Java项目中是将所有的jar包统一拷贝的同一目录中，可能会存在jar包文件名称冲突的问题！
(4)在进行项目整合时，可能会出现jar包版本冲突的问题。
(5)在传统java项目中通过编译（手动编译或者在eclipse保存自动编译）、测试（手动在main函数中测试、junit单元测试）、打包部署(手动打war包/手动发布)、运行(手动启动tomcat运行)，最终访问程序。
2、使用Maven来管理jar包的优势：
(1)Maven团队维护了一个非常全的Maven仓库(中央仓库)，其中几乎包含了所有的jar包，使用Maven创建的工程可以自动到Maven仓库中下载jar包，方便且不易出错。
另外，在Maven构建的项目中，如果要使用到一些框架，我们只需要引入框架的核心jar包，框架所依赖的其他第三方jar包，Maven也会一并去下载。
(2)在Maven构建的项目中，不会将项目所依赖的jar包拷贝到每一个项目中，而是将jar包统一放在仓库中管理，在项目中只需要引入jar包的位置(坐标)即可。这样实现了jar包的复用。
(3)Maven采用坐标来管理仓库中的jar包，其中的目录结构为【公司名称+项目/产品名称+版本号】，可以根据坐标定位到具体的jar包。即使使用不同公司中同名的jar包，坐标不同（目录结构不同），文件名也不会冲突。
(4)Maven构建的项目中，通过pom文件对项目中所依赖的jar包及版本进行统一管理，可避免版本冲突。
(5)在Maven项目中，通过一个命令或者一键就可以实现项目的编译（mvn complie）、测试（mvn test）、打包部署（mvn deploy）、运行（mvn install）等。
还有发布到tomcat服务器中运行: mvn tomcat7:run。如果想实现上面的所有过程，只需要记住一个命令：mvn install
总之，使用Maven遵循规范开发有利于提高大型团队的开发效率，降低项目的维护成本，大公司都会优先使用Maven来构建项目.
54、什么是mybatis?使用mybatis有什么优势？
MyBatis 本是apache的一个开源项目iBatis，2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。
总之，Mybatis对JDBC访问数据库的过程进行了封装，简化了JDBC代码，解决JDBC将结果集封装为Java对象的麻烦。
1、使用传统方式JDBC访问数据库：
(1)使用JDBC访问数据库有大量重复代码（比如注册驱动、获取连接、获取传输器、释放资源等）；
(2)JDBC自身没有连接池，会频繁的创建连接和关闭连接，效率低；
(3)SQL是写死在程序中，一旦修改SQL，需要对类重新编译；
(4)对查询SQL执行后返回的ResultSet对象，需要手动处理，有时会特别麻烦；
…
2、使用mybatis框架访问数据库：
(1)Mybatis对JDBC对了封装，可以简化JDBC代码；
(2)Mybatis自身支持连接池（也可以配置其他的连接池），因此可以提高程序的效率；
(3)Mybatis是将SQL配置在mapper文件中，修改SQL只是修改配置文件，类不需要重新编译。
(4)对查询SQL执行后返回的ResultSet对象，Mybatis会帮我们处理，转换成Java对象。
…
总之，JDBC中所有的问题（代码繁琐、有太多重复代码、需要操作太多对象、释放资源、对结果的处理太麻烦等），在Mybatis框架中几乎都得到了解决！！
55、mybatis中#{}与${}的区别？
#{}：
相当于JDBC中的问号（?）占位符，是为SQL语句中的参数值进行占位，大部分情况下都是使用#{}占位符；并且当#{}占位符是为字符串或者日期类型的值进行占位时，在参数值传过来替换占位符的同时，会进行转义处理（在字符串或日期类型的值的两边加上单引号）
${}：
是为SQL片段（字符串）进行占位，将传过来的SQL片段直接拼接在 ${} 占位符所在的位置，不会进行任何的转义处理。（由于是直接将参数拼接在SQL语句中，因此可能会引发SQL注入攻击问题）
需要注意的是：使用 ${} 占位符为SQL语句中的片段占位时，即使只有一个占位符，在传递
对应的值时，即使只有一个参数，也需要将值存入map集合中！！也需要将参数先封装再传递！
56、什么是动态SQL?什么情况下使用动态SQL？
动态SQL：code that is executed dynamically。就是（在进行sql操作的时候）动态的根据属性值（所匹配的条件）来拼接数据库执行的sql语句，也就是多次查询或变更操作，根据传入的属性值不同，动态拼接出不同的可执行sql。包含判断为空、循环等；
查询条件往往是这样一种非常常见的逻辑：如果客户填了查询信息，则查询该条件；如果客户没填，则返回所有数据。
可组合成非常灵活的SQL语句，从而提高编程效率。
57、动态SQL常用标签有哪些？
Mybatis动态sql（有哪些）标签：
1、:
if是为了判断传入的值是否符合某种规则，比如是否不为空；
2、:
where标签可以用来做动态拼接查询条件，当和if标签配合的时候，不用显示的声明类似where 1=1这种无用的条件；
3、:
这是一组组合标签，他们的作用类似于 Java 中的 switch、case、default。只有一个条件生效，也就是只执行满足的条件 when，没有满足的条件就执行 otherwise，表示默认条件；
4、:
foreach标签可以把传入的集合对象进行遍历，然后把每一项的内容作为参数传到sql语句中，里面涉及到 item(具体的每一个对象), index(序号), open(开始符), close(结束符), separator(分隔符)；
5、:
include可以把大量重复的代码整理起来，当使用的时候直接include即可，减少重复代码的编写；
6、:
适用于更新中，当匹配某个条件后，才会对该字段进行更新操作
7、:
是一个格式化标签，主要有4个参数:
prefix(前缀)；
prefixOverrides(去掉第一个标记)；
suffix(后缀)；
suffixOverrides(去掉最后一个标记)；
58、什么是Spring？它的优势是什么？
spring是分层的JavaSE及JavaEE应用于全栈的轻量级开源框架，以IoC（Inverse Of Control：控制反转/反转控制）和AOP（Aspact Oriented Programming：面向切面编程）为核心，提供了表现层SpringMVC和持久层SpringJDBC以及业务层事务管理等众多模块的企业级应用技术，还能整合开源世界中众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架。
优势：
1).方便解耦，简化开发
通过 Spring提供的 IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为较为底层的需求编写代码，可以更专注于上层的应用。
2).AOP 编程的支持
通过 Spring的 AOP 功能，方便进行面向切面的编程，许多不容易用传统OOP（Object Oriented Programming：面向对象编程） 实现的功能可以通过 AOP 轻松应付。
3).声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
4).方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
5).方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
6).降低 JavaEE API 的使用难度。
Spring对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API 的使用难度大为降低。
7).Spring框架源码是经典学习范例
Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对 Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践的范例。
59、Spring的核心内容是什么？
Spring是一个无侵入式的轻量级开源框架
Spring两大特性 :
1.IOC:控制反转
IOC作用:解除类与类之间的关系耦合
解除耦合的方式用了四个技术点:

1. 配置
2. 容器
3. 反射
4. 注入(DI):利用set方法或者构造器给属性赋值
   2.AOP:面相切面编程
   作用:为了解除业务逻辑耦合,例如耦合或者数据业务逻辑日志业务
   AOP实现原理是基于代理的
   Spring进行内部实现的时候 ,会检测是否存在接口,存在时选择jdk动态代理,不存在选择CGLIB代理
   Spring类似一个管家,后期几乎所有内容都交给Spring管理,View层Spring不管理,与java相关的全部管理.(Spring容器)
   Spring的核心思想是解除程序中的耦合(解除了业务逻辑耦合,解除了类与类之间的关系耦合)
   轻量级与重量级的区分:
   1.性能开销
   2.框架本身的大小问题
   3.使用的难易程度
   Spring中所有的行为都是基于Spring能够管理所有的类
   Spring也有持久层框架,但是因为性能不强,所以没有人用,用来给hibernate和mybitas支持
   Spring对web框架也是有支持的
   Spring还是一个mvc结构的框架
   Core解除的是类级别的耦合
   AOP解除的是方法级别的耦合
   IOC控制反转 Inversion Of Control
   高层模块不应该依赖底层模块(如Action依赖Dao层)
   实现必须依赖抽象,而不是是抽象依赖实现
   依赖注入:Dependency Injection
   DI是IOC的核心实现原理
   通俗的说就是利用set方法或者构造器给属性赋值
   59.Spring的核心内容是什么？
   IOC、DI、AOP
   60.IOC、AOP各是什么
   spring的核心内容就是控制反转IOC、依赖注入DI和面向切面编程AOP
   IOC：传统的JAVA开发模式中，当需要一个对象时，我们使用new，直接或者间接调用构造方法创建一个对象，而在Spring开发模式中，Spring容器使用工厂模式为我们创建了所需要的对象，不需要我们自己去创建了，直接调用Spring提供的对象就可以了，这就是控制反转。
   DI：Spring使用JavaBean对象的set方法或者带参数的构造方法为我们在创建所需要对象时将其属性自动设置为我们所需要的值的过程，这就是依赖注入。
   AOP：AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等
   61.什么是MVC?工作原理？
   MVC就是一种设计模式，它就是强制性使应用程序的输入，处理和输出分开。将一个应用程序分为三个部分：Model，View，Controller。
   springmvc的工作原理是：
   前端控制器（DispatcherServlet）：主要负责捕获来自客户端的请求和调度各个组件。
   处理器映射器（HandlerMapping）：根据url查找后端控制器Handler。
   处理器适配器（HandlerAdapter）：执行后端控制器（Handler），拿到后端控制器返回的结果ModelAndView后将结果返回给前端控制器DispatcherServlet。
   后端控制器（处理器）（Handler）：主要负责处理前端请求，完成业务逻辑，生成ModelAndView对象返回给HandlerAdapter。
   视图解析器（ViewResolver）：主要负责将从DispatcherServlet中拿到的ModelAndView对象进行解析，生成View对象返回给DispatcherServlet。
   62.springboot？
   是一个脚手架一种全新的编程规范，他的产生简化了框架的使 用，所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置 文件，主要作用是简化配置文件。
   63.1.什么是AOP（Aspect Orient Programming）？解决了什么问题？应用原理?应用场景
   ?
   是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。
   2.解决的问题
   实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块，一个模块有哪些对象，对象有哪些属性)，面向切面的运行期代理方式，理解为一个动态过程，可以在对象运行时动态织入一些扩展功能或控制对象执行。
   3.应用原理
   1）假如目标对象(被代理对象)实现接口，则底层可以采用JDK动态代理机制为目标对象创建代理对象（目标类和代理类会实现共同接口）。
   2）假如目标对象(被代理对象)没有实现接口，则底层可以采用CGLIB代理机制为目标对象创建代理对象（默认创建的代理类会继承目标对象类型）。
   4.应用场景
   实际项目中通常会将系统分为两大部分，一部分是核心业务，一部分是非核业务。在编程实现时我们首先要完成的是核心业务的实现，非核心业务一般是通过特定方式切入到系统中，这种特定方式一般就是借助AOP进行实现。
   64.基本步骤： 切面/方面（Aspect）
   切入点（Pointcut）
   目标对象（Target Object）
   AOP代理（AOP Proxy）
   过程：要利用切面，我们不直接在3个方法进行调用，将方法进行抽取出来分离关注点，被通知的对象Advice。
   spring会根据配制文件中配制的切入点去匹配target中方法的调用，从而知道哪些方法需要增加。
   当客户端调用这些方法时，直接调用的是代理对象的方法。
   AOP通过配制文件中配制的切入点与Advice，从而找到指定方法需要增强的功能。
   最终通过代理将Advice动态织入到指定方法。
5. 切面/方面（Aspect）
   切入点（Pointcut）
   目标对象（Target Object）
   AOP代理（AOP Proxy）
   66.基于此依赖spring可以整合AspectJ框架快速完成AOP的基本实现。AspectJ 是一个面向切面的框架，他定义了AOP的一些语法，有一个专门的字节码生成器来生成遵守java规范的class文件。
   @Aspect 注解用于标识或者描述AOP中的切面类型，基于切面类型构建的对象用于为目标对象进行功能扩展或控制目标对象的执行。
   @Pointcut注解用于描述切面中的方法，并定义切面中的切入点（基于特定表达式的方式进行描述），在本案例中切入点表达式用的是bean表达式，这个表达式以bean开头，bean括号中的内容为一个spring管理的某个bean对象的名字。
   @Around注解用于描述切面中方法，这样的方法会被认为是一个环绕通知（核心业务方法执行之前和之后要执行的一个动作），@Aournd注解内部value属性的值为一个切入点表达式或者是切入点表达式的一个引用(这个引用为一个@PointCut注解描述的方法的方法名)。
   ProceedingJoinPoint类为一个连接点类型，此类型的对象用于封装要执行的目标方法相关的一些信息。一般用于@Around注解描述的方法参数。

@Aspect 指定一个类为切面类
@Pointcut(“execution(* cn.itcast.e_aop_anno..(…))”) 指定切入点表达式
@Before(“pointCut_()”) 前置通知: 目标方法之前执行
@After(“pointCut_()”) 后置通知：目标方法之后执行（始终执行）
@AfterReturning(“pointCut_()”) 返回后通知： 执行方法结束前执行(异常不执行)
@AfterThrowing(“pointCut_()”) 异常通知: 出现异常时候执行
@Around(“pointCut_()”) 环绕通知： 环绕目标方法执行
68.启用声明式事务管理，在项目启动类上添加@EnableTransactionManagement，新版本中也可不添加（例如新版Spring Boot项目）。
将@Transactional注解添加到合适的业务类或方法上，并设置合适的属性信息。
69.
1).启动异步配置
在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，
2).Spring中@Async注解应用
70.在业务方法中我们可能调用数据层方法获取数据库中数据,假如访问数据的频率比较高,为了提高的查询效率,降低数据库的访问压力,可以在业务层对数据进行缓存.
71. 1）良好的基因 因为SpringBoot是伴随着Spring 4.0而生的，boot是引导的意思，也就是它的作用其实就是在于帮助开发者快速的搭建Spring框架，因此SpringBoot继承了Spring优秀的基因在Spring中开发更为方便快捷。
2）简化编码 比如我们要创建一个web项目，使用 Spring 的朋友都知道，在使用 Spring 的时候，需要在 pom 文件中添加多个依赖，而 Spring Boot 则会帮助开发着快速启动一个 web 容器，在 Spring Boot 中，我们只需要在 pom 文件中添加starter-web 依赖即可。
3）简化配置 Spring 虽然使Java EE轻量级框架，但由于其繁琐的配置，一度被人认为是“配置地狱”。各种XML、Annotation配置会让人眼花缭乱，而且配置多的话，如果出错了也很难找出原因。Spring Boot更多的是采用 Java Config 的方式，对 Spring 进行配置
4）简化部署 在使用 Spring 时，项目部署时需要我们在服务器上部署 tomcat，然后把项目打成 war 包扔到 tomcat里，在使用 Spring Boot 后，我们不需要在服务器上去部署 tomcat，因为 Spring Boot 内嵌了 tomcat，我们只需要将项目打成 jar 包，使用 java -jar xxx.jar一键式启动项目。
另外，也降低对运行环境的基本要求，环境变量中有JDK即可
5）简化监控 我们可以引入 spring-boot-start-actuator 依赖，直接使用 REST 方式来获取进程的运行期性能参数，从而达到监控的目的，比较方便。但是 Spring Boot 只是个微框架，没有提供相应的服务发现与注册的配套功能，没有外围监控集成方案，没有外围安全管理方案，所以在微服务架构中，还需要 Spring Cloud 来配合一起使用。
72.Shiro是apache旗下一个开源安全框架(http://shiro.apache.org/)，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。
73.Subject :主体对象，负责提交用户认证和授权信息。
SecurityManager：安全管理器，负责认证，授权等业务实现。
Realm：领域对象，负责从数据层获取业务数据。
74.系统调用subject的login方法将用户信息提交给SecurityManager
SecurityManager将认证操作委托给认证器对象Authenticator
Authenticator将用户输入的身份信息传递给Realm。
Realm访问数据库获取用户信息然后对信息进行封装并返回。
Authenticator 对realm返回的信息进行身份认证。
75.系统调用subject相关方法将用户信息(例如isPermitted)递交给SecurityManager。
SecurityManager将权限检测操作委托给Authorizer对象。
Authorizer将用户信息委托给realm。
Realm访问数据库获取用户权限信息并封装。
Authorizer对用户授权信息进行判定。
76.当我们进行授权操作时,每次都会从数据库查询用户权限信息,为了提高授权性能,可以将用户权限信息查询出来以后进行缓存,下次授权时从缓存取数据即可。
77.客户端业务实现
在页面上选中记住我,然后执行提交操作,将用户名,密码,记住我对应的值提交到控制层
服务端业务实现
在SysUserController中的doLogin方法中基于是否选中记住我，设置token的setRememberMe方法。
78.使用shiro框架实现认证操作,用户登录成功会将用户信息写入到会话对象中,其默认时长为30分钟,