Java基础面试题

1: Arraylist和Linkedlist的区别?

  ArrayList

1）ArrayList底层数组结构，原理：数组复制

2）底层自动扩容数组，初始为10，每次扩容上次的1/2

3）善于查询

4）利用index按顺序存储

LinkedList

1）底层链表结构（双链表）

2）善于插入删除数据

3）特殊方法：addLast（），addFirst（），removeFirst（），remove（）删除第一个；removeLast（）

总结：ArrayList更适合读取数据，linkedList更多的时候添加或删除数据。

ArrayList内部是使用可増长数组实现的，因此是用get和set方法是花费常数时间的，可是若是插入元素和删除元素，除非插入和删除的位置都在表末尾，不然代码开销会很大，由于里面须要数组的移动。
LinkedList是使用双链表实现的，因此get会很是消耗资源，除非位置离头部很近。可是插入和删除元素花费常数时间。

2:重载与重写有什么区别?

重写：不一样类中，方法体结构相同，逻辑代码能够不一样，方法被定义为final不能被重写。

重载：同一类中，方法体结构相同参数列表类型和个数不能相同。

3: &和&&有什么区别?

&和&&均可以做逻辑与，&它的左边不管是true仍是false，右边的条件都要进行判断，&&它的左边若是是false，右边则不用进行判断。

&能够用做位运算符，将左边和右边两个数转换成二进制数而后进行与运算。

 

4:接口和抽象类有什么区别?

抽象类特色：

1）不能被实例化（子类继承后可实例化子类）

2）充当父类

3）有属性，方法，构造方法，抽象方法

4）抽象类中抽象方法必须被重写

5）子类有且只有一个父类

   接口特色：

1）不能被实例化

2）充当父接口

3）有属性，抽象方法（属性必须初始化，且不能更改）

4）子类能够实现多个接口

抽象类（abstract class）：
1：abstract 关键字修饰，而且没有方法体
2：抽象类不能直接建立实例
3：抽象类只能被继承，一个具体类继承一个抽象类，必须实现全部抽象方法
接口（interface）：
1：实现接口的必定要实现接口里定义的全部方法
2：接口能够实现多重继承
区别：
1：抽象类和接口都不可以实例化，但能够定义抽象类和接口类型的引用
2：一个类若是继承了某个抽象类或者实现了某个接口都须要对其中的抽象方法所有进行实现，不然该类仍然须要被声明为抽象类
3：接口比抽象类更加抽象，由于抽象类中能够定义构造器，能够有抽象方法和具体方法，而接口中不能定义构造器并且其中的方法所有都是抽象方法
4：抽象类中的成员能够是private、默认、protected、public的，而接口中的成员全都是public的
5：抽象类中能够定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法

6.接口能够继承接口，甚至能够继承多个接口；类能够实现多个接口，只能继承一个类。

 

5:写出JDBC操做数据库的步骤?
1：加载驱动
 Class.forName("com.mysql.jdbc.Driver");
2：建立链接
Connection con = DriverManager.getConnection ("url", "1111", "1111");
3：建立语句
PreparedStatement ps = con.prepareStatement("select * from user");
4：执行语句
ResultSet rs = ps.executeQuery();
5：处理结果
   while(rs.next()) {
       rs.get.....（“”）；
   }
6：关闭资源
   finally {
       if(con != null) {
           try {
               con.close();
           } catch (SQLException e) {
               e.printStackTrace();
           }
       }
   }

加载驱动-建立链接-建立语句-执行语句-处理结果-关闭资源

6: HashTable和HashMap有什么区别?

1. HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口
2.主要区别在于HashMap容许空（null）键值（key）,因为非线程安全，效率上可能高Hashtable
3.HashMap容许将null做为一个entry的key或者value，而Hashtable不容许
4.最大的不一样是，Hashtable的方法是Synchronize的，而HashMap不是

   HashMap线程不安全。HashMap是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，而且不能包含重复键，但能够包含重复值。HashMap容许包含空键和空值，而HashTable不容许空键值。

   HashTable线程安全。HashMap是HashTable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap容许空键值，因为非线程安全，因此效率上可能高于HashTable。

 

7;建立多线程的方式有几种?分别是什么?线程死锁是如何产生的?如何防止线程死锁现象?

方式：继承Thread、实现 Runnable 接口
产生:
   - 一个资源每次只能被一个进程使用
   - 一个进程因请求发生阻塞时，依然对已得到的资源保持不放
   - 进程已经得到资源使用权，可是一直未使用
   - 同一个进程，频繁的获取资源的优先使用权，一直未释放
防止：
   加锁顺序（线程按照必定的顺序加锁）
   加锁时限（线程尝试获取锁的时候加上必定的时限，超过期限则放弃对该

锁的请求，并释放本身占有的锁）
   死锁检测（通常是将全部的锁存放于map对象中，检测map中的锁）

 

8: String,StringBuffer, StringBuilder 的区别?

1.运行速度快慢为：StringBuilder > StringBuffer > String
   - （String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦建立以后该对象是不可更改的）
  2.StringBuilder是线程不安全的，而String、StringBuffer是线程安全的

 

9: TCP和UDP的区别?哪一个是三次握手协议?

TCP稳定性较高，但效率低。TCP三次握手协议。
UDP通信相反，效率较高，但稳定性较差

 

10: JSP的经常使用指令有哪些?

三个编译指令为：page、include、taglib
七个动做指令为：jsp:forward、jsp:param、jsp:include、jsp:plugin、

jsp:useBean、jsp:setProperty、jsp:getProperty

 

11: DI有几种方式、分别是什么，你经常使用的是哪一种方式?

1：Setter方法
2：构造器
3：接口注入  注解实现注入(经常使用)

 

12; Mybatis中$和#在xm1中取值有什么不一样?

1.mybatis 为咱们提供了两种支持动态 sql 的语法：#{} 以及 ${}
2.#方式可以很大程度防止sql注入，$方式没法防止Sql注入
3.$方式通常用于传入数据库对象，例如传入表名
4.＃{}将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
5.通常能用#的就别用$

 

13: Session和Cookie有什么区别?

Cookie和session作状态管理

Cookie存在客户端、session数据放在服务器上
cookie不是很安全，别人能够分析存放在本地的COOKIE并进行修改
session会在必定时间内保存在服务器上。当访问增多，会比较占用你服务器

的性能
单个cookie在客户端的限制是3K，就是说一个站点在客户端存放的COOKIE

不能大于3K

 

14: GET和POST请求的区别?

GET：
   1：从服务器上获取数据，通常不能使用在写操做接口
   2：由URL所限制，GET方式传输的数据大小有所限制，传送的数据量不超过2KB
   3：请求的数据会附加在URL以后，以？分隔URL和传输数据，多个参数用&链接
   4：安全性差
POST:
   1：向服务器提交数据,通常处理写业务
   2：POST方式传送的数据量比较大，通常被默认为没有限制
   3：安全性高
   4：请的求的数据内容放置在HTML HEADER中

 

15:转发(forward) 和重定向(redirect)的区别?

1：效率上
   转发（forward） > 重定向（redirect）
  2：显示上
   重定向（redirect）：显示新的URL
   转发（forward）：地址栏不变
  3：数据上
   转发（forward）：能够共享request里面的数据
   重定向（redirect）：不能
  4：请求次数
   重定向（redirect）是两次
   转发（forward）是一次

 

16: Hibernate与Mybatis区别?

1：hibernate的扩展性和移植性比mybatis强
2：hibernate不须要写sql语句，会自动生成，而mybatis则须要写sql

语句
3：hibernate支持事务、一级缓存、二级缓存、查询缓存等
4：hibernate本身提供分页功能，mybatis须要配置分页插件

 

17: 列举struts2常见的组件有哪些?常见的配置标签有哪些?返回值类型有哪些?

组件：
   strutsParperAndExecuteFilter
   Action
   Result
   Interceptor
标签：
   package
   action
   result
   param
   interceptor
返回值类型：
   dispatcher
   redirect
   redirectAction
   stream
   json

 

18: 用最有效率的方法算出2乘以8等于多少?

2 << 3

 

19: Spring常见的注解有哪些?

@Autowired--自动装配
@Component--自动支持自动装配
@Repository--DAO层实现
@Service--Service层实现
@Controller--Web层实现

 

28: Debug模式下，快捷键有哪些，分别表明什么?

F5：进入方法内
F6：执行下一步
F7：跳出方法外
F8：执行到下一个断点

 

21: Tomcat如何修改端口号，如何清除项目缓存，默认并发量是多少?

端口：server.xml
项目缓存：删除work文件夹下的文件
并发：150-200

 

22: final, finally, finalize的区别?

final—修饰符（关键字）
   若是一个类被声明为final，意味着它不能再派生出新的子类，不能做为父类被继承。
   一个类不能既被声明为 abstract的，又被声明为final的，被声明为final的方法也一样只能使用，不能重载
   finally—异常处理时提供 finally 块来执行操做
   finally块则是不管异常是否发生，都会执行finally块的内容
   finalize—方法名
   finalize() 方法是在垃圾收集器删除对象以前对这个对象调用的，它是在object类中定义的，全部的类都继承了它

 

23:一个汉字几个字节，一个char类型的变量，能够储存一个汉字吗，为何能够或者不能够?

两个字节，能够存储，前提是汉字必须是Unicode编码

 

24:谈谈Spring AOP的原理?

AOP称为面向切面编程
用于处理系统中分布于各个模块的横切关注点，好比事务管理、日志、缓存

等等实现AOP功能关键是采用代理技术，主要分为静态代理(AspectJ)和动态代

理，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，若是要

为某个类生成子类，则能够用CGLIB。

 

25:简要说明SSH框架搭建步骤?

1：Struts2
   - 导包
   - 加载struts.xml
   - 配置web.xml
       - filter
   2：Struts2+Spring
   - 导中间包、Spring包
   - 增长Spring的配置文件Applicationcontext.xml
   - 配置web.xml
       - context和监听
   3：Hibernate
   - 导包
   - 增长hibernate的配置文件hibernate.hbm.cfg和表的映射文件
       - 配置数据库的方言和链接、加载映射文件
   4：Hibernate+Spring
   - 导中间包
   - 在spring的配置文件中加载hibernate的配置信息

26:简要说明SSM框架搭建步骤?

1: Spring
   - 导包
   - 增长Spring的配置文件Applicationcontext.xml
   - 配置web.xml
  2：springMVC
   - 导包
   - 增长springMVC的配置文件context-dispatcher.xml
   - 配置web.xml
  3：mybatis
   - 导包
   - 增长mybatis的配置文件mybatis-config.xml
   - 将mybatis的配置文件在spring和springMVC中进行引用和配置

 

27:多线程中run和start方法有什么区别?

Thread的start才是正在开启线程;Run只是调用了一个普通方法，并无启动另外一个线程，程序仍是会按照顺序执行相应的代码。Start则表示，从新开启一个线程，没必要等待其余线程运行完，只要获得cup就能够运行该线程。

 

28:静态变量和实例变量有什么区别?

静态变量前面要加static，实例变量不用。实例变量属于对象的属性，必须建立了实例对象，才能够被使用，静态变量不属于某个实例对象，而是属于类，也叫类变量，不用建立任何实例对象就会被使用。

29:先后台数据交互的方式有哪些?

json、file、xml、jsonp等

 

30:字节流和字符流有什么区别?

字节流：按字节读写
字符流：按字符
一般在处理文本时优先使用字符流，其余的用字节流

字节流在操做时自己不会用到缓冲区（内存），是文件自己直接操做的，而字符

流在操做时使用了缓冲区，经过缓冲区再操做文件

 

31: Redis支持哪些数据类型的存储?

string、list、set、zset、hash

 

32: Java如何调用Redis进行数据操做，并列举增删改查操做?

1.导包

2. Jedis jd = new Jedis(IP);

3. jd.ping();//PONG

 

33: Nosql主要支持哪两种数据存储系统?

key-value---Redis
文档存储-----MongoDB

 

34: MongoDB的体系逻辑结构，主要有什么组成?

文档(document)、集合(collection)、数据库(database)

 

35: Redis和MongoDB分别应用于哪些应用场景?

Redis：数据量较小的更性能操做和运算上

MongoDB:主要解决海量数据的访问效率问题

 

36: Java如何连接MongoDB,写出逻辑代码?

导包

//创建链接
MongoClient mc =  new MongoClient("192.168.168.220", 27017); MongoDatabase db = mc.getDatabase("db1");//数据库名称

 

37:如何给张表增长一个字段，写出sq1语句?

alter table 表名 add 字段 类型 NOT NULL Default 0;

 

38: ==与equals有什么区别?

==：比较两个数据内存地址是否相同

equals：比较两个数据值是否同样

 

39: ++i与i++的区别?

++i:先赋值，后运算

i++：先运算，后赋值

 

40: List和Map有什么区别?

list：
   - 链表
   - 有序
   - 继承Collection(set也是)
   - 能够有重复的对象值，可是对象下标不能重复
   Map：
   - key-value
   - 无序
   - 键不能有重复的 值能够用

 

41: Integer与int的区别?

int 是基本数据类型，初值为0。Integer是int的包装类，初值为null
Integer缓存：注意拆箱和装箱（-128-127之间）
原始类型：boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

 

42:分别写出oracle、mysq1的分页关键词?

oracle：rownum关键词、row_number()函数
mysql：limit 0,5    /    limit 5;

 

43:谈谈你对MVC的理解?

MVC：是一个框架设计模式，其中M（模型）、V（视图）、C（控制器）
视图：视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业

务逻辑处理。如：jsp、html等
模型：表示业务数据和业务处理。属于数据模型，如:entity、jdbc、

hibernate、mybatis等
控制器：接收、响应用户请求，servlet、action、controller等

 

44、若是equals方法比较为true,那么它们的Hashcode值必定相同吗?若是hashcode相同，那么equals方法比较一定为true吗?

不必定相同；必定

 

45:简述servlet生命周期?

经过调用 init () 方法进行初始化；调用 service() 方法来处理客户端的请求；经过调用 destroy() 方法终止（结束）Servlet 是由 JVM 的垃圾回收器进行垃圾回收的；

 

46:进程和线程的区别是什么?

- 进程是资源的分配和调度的一个独立单元，而线程是CPU调度的基本单元
- 同一个进程中能够包括多个线程
- 进程结束后它拥有的全部线程都将销毁，而线程的结束不会影响同个进程中的其余线程的结束
- 线程共享整个进程的资源（寄存器、堆栈、上下文），一个进行至少包括一个线程
- 进程的建立调用fork或者vfork，而线程的建立调用pthread_create
- 线程中执行时通常都要进行同步和互斥，由于他们共享同一进程的全部资源

 

47:进程的几种状态分别是什么?

就绪状态：
   当进程已分配到除CPU之外的全部必要的资源，只要得到处理机即可当即执行，这时的进程状态称为就绪状态。
运行状态：
   当进程已得到处理机，其程序正在处理机上执行，此时的进程状态称为运行状态。
阻塞状态：
  正在运行的进程，因为等待某个事件发生而没法执行时，便放弃处理机而处于阻塞状态。引发进程阻塞的事件可有多种，例如，等待I/O完成、申请缓冲区不能知足、等待信件(信号)等。
状态转换：
   就绪→运行：处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成运行状态。
   运行→就绪：处于运行状态的进程在其运行过程当中，因分配给它的一个时间片已用完而不得不让出处理机，因而进程从运行状态转变成就绪状态。
   运行→阻塞：正在运行的进程因等待某种事件发生而没法继续运行时，便从运行状态变成阻塞状态。
   阻塞→就绪：处于阻塞状态的进程，若其等待的事件已经发生，因而进程由阻塞状态转变为就绪状态。

 

48: JDK和JRE的关系区别是什么?

JDK是Java的开发工具，JDK包含JRE。
JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）

及核心类库。

 

49: SpringMVC运行原理是什么?

1. 客户端请求提交到DispatcherServlet
   2.由DispatcherServlet控制器查询一个或多个HandlerMapping，找到

处理请求的Controller
3.DispatcherServlet将请求提交到Controller
4.Controller调用业务逻辑处理后，返回ModelAndView
5.DispatcherServlet查询一个或多个ViewResoler视图解析器，找到

ModelAndView指定的视图
6.视图负责将结果显示到客户端
DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求

组织协调Spring MVC的各个组成部分

 

50：用户在浏览器中输入URL以后，发什么了什么?写出请求和响应的流程

1：域名解析
2：TCP三次握手
3：浏览器向服务器发送http请求
4：浏览器发送请求头信息
5：服务器处理请求
6：服务器作出应答
7：服务器发送应答头信息
8：服务器发送数据
9：TCP链接关闭

 

51:响应结果状态码有哪些，并给出中文含义?

    1**：信息性状态码
2**：成功状态码
   200：请求正常成功
   204：指示请求成功但没有返回新信息
   206：指示服务器已完成对资源的部分 GET 请求
3**：重定向状态码
   301：永久性重定向
   302：临时性重定向
   304：服务器端容许请求访问资源，但未知足条件
4**：客户端错误状态码
   400：请求报文中存在语法错误
   401：发送的请求须要有经过HTTP认证的认证信息
   403：对请求资源的访问被服务器拒绝了
   404：服务器上没法找到请求的资源
5**：服务器错误状态码
   500：服务器端在执行请求时发生了错误
   503：服务器暂时处于超负载或正在进行停机维护，如今没法处理请求

 

52: 什么是ORM?

对象关系映射（Object Relational Mapping，简称ORM）
为了解决面向对象与关系数据库存在的互不匹配的现象的技术，ORM是经过使用描述对象和数据库之间映射的元数据(元数据通常采用XML格式)，将程序中的对象自动持久化到关系数据库中，Java典型的ORM中间件有:Hibernate,ibatis,speedframework,mybatis

 

53:什么是IOC?

(Inversion of Control,简称IOC)，即控制反转，是一种设计模式，是spring的核心。能够解决代码耦合，由IOC容器来管理对象的生命周期、依赖关系等。

 

54:jsp的做用域有哪些?

page：当前页面有效
request：一次会话请求有效
session：浏览器进程，只要浏览器不关闭，则一直有效
application：服务器只要运行，则有效

 

55: sleep和wait 有什么区别?

sleep：
   1：属于Thread类，表示让一个线程进入睡眠状态，等待必定的时间以后，自动醒来进入到可运行状态，不会立刻进入运行状态
   2：sleep方法没有释放锁
   3：sleep必须捕获异常
wait：
   1：属于Object，一旦一个对象调用了wait方法，必需要采用notify()和notifyAll()方法唤醒该进程
   2：wait方法释放了锁
   3：wait不须要捕获异常

 

56: Java 中的final关键字有哪些用法?

1：修饰类：表示该类不能被继承
2：修饰方法：表示方法不能被重写
3：修饰变量：表示变量只能一次赋值之后值不能被修改（常量）

 

57: Error和Exception有什么区别?何时须要捕获异常，何时须要抛出异常?

1:Error表示系统级的错误和程序没必要处理的异常,有可能恢复，可是恢复比较困难的严重问题。
2：Exception表示须要捕捉或者须要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示若是程序运行正常，从不会发生的状况
异常处理的原则：
   1：System.out.println是高代价的。调用System.out.println会下降系统吞吐量
   2：在生产环境中别用异常的printStackTrace()方法。
   3：若是你不能处理异常，不要捕获该异常
   4：若是要捕获，应在离异常源近的地方捕获它
   5：捕获的异常必定要作处理
   6：能够自定义异常
   7：就近原则

 

58:写出冒泡排序的程序代码?

 

59:数据库集群模式下，如何保证主从数据库的数据一致性?

以mysq1数据库为例进行说明配置步骤？

1：开启全部服务器的二进制文件
2：开启全部从服务的IO和SQL线程
3：配置主从链接的用户信息和主从信息
4：开启3306端口号

 

60: 简述JAVA中I/O和NIO的区别?

NIO:是一种new IO，其目的是为了实现高速IO的代码，将IO操做并转换为操做系统，属于非阻塞型，java.nio.*，是以块（缓冲区）的形式就行数据的传输。
IO：是以流的方式就行数据的传输，属于阻塞型，影响程序的性能
传统阻塞IO，若是你要read/write( byte[10M])一个10M的文件，一旦调用了read/write( byte[10M])这个方法，就得等10M所有read/write，方法底层才会返回。
非阻塞线程，调用read/write( byte[10M])方法当即返回，固然这并不能表明10M已经read/write完成，你须要检测这个byte[10M]的缓冲区。

 

61:简述单例模式的特征和应用场景?

单例模式（Singleton），也叫单子模式，是一种经常使用的软件设计模式。在应用这个模式时，单例对象的类必须保证只有一个实例存在。
单例模式只容许建立一个对象，所以节省内存，加快对象访问速度
单例模式要素：
   a.私有构造方法
   b.私有静态引用指向本身实例
   c.以本身实例为返回值的公有静态方法
饿汉式：单例实例在类装载时就构建，急切初始化。（预先加载法）
   优势
       1.线程安全
       2.在类加载的同时已经建立好一个静态对象，调用时反应速度快缺点
        资源效率不高，可能getInstance()永远不会执行到，但执行该类的其余静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化
懒汉式：单例实例在第一次被使用时构建，延迟初始化。
应用场景：
   - 须要频繁实例化而后销毁的对象
   - 建立对象时耗时过多或者耗资源过多，但又常常用到的对象
   - 有状态的工具类对象
   - 频繁访问数据库或文件的对象
   - 网站计数器，通常是采用单例模式实现
   - 因为配置文件通常都是共享资源，即web应用的配置对象的读取，通常采用单例模式来实现。如：spring的配置文件的读取等
   - 多线程的线程池的设计通常也是采用单例模式
   - 数据库链接池的设计

 

62:写出将1000个存在重复手机号的号码池去重的JAVA代码?

 

63:Java接口的修饰符有哪些?

public、final、abstract

 

64:Java支持的数据类型有哪些?什么是自动拆装

8种基本数据类型：
   byte      8位         取值范围  -2^7 ~ 2^7 -1
   short     16位        取值范围  -2^15 ~ 2^15 - 1
   char      16位        取值范围  0 ~ 2 ^16 - 1
   boolean   位数不明确   取值范围  true false
   int       32位        取值范围  -2^31 ~ 2^31 - 1
   long      64位        取值范围  -2^63 ~ 2^ 63 - 1
   float     32位        取值范围  1.4e-45 ~ 3.40e38
   double    64位        取值范围  4.9e-324 ~ 1.79e308
注意：
   须要注意的是，String不是基本数据类型，而是引用类型
在jdk1.5中引入了自动拆装箱的新特性，自动拆装箱，是指基本数据类型和引用数据类型之间的自动转换
   基本类型转换成包装类型，称为装箱  
   Integer intObjct = new Integer(2); //装箱
   //Integer intObjct = 2 //自动装箱  
   //自动装箱，若是一个基本类型值出如今须要对象的环境中，会自动装箱  
   如Integer 和 int 能够自动转换； Float和float能够自动转换

 

65:Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

round方法，他表示“四舍五入”，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整
十二、-11

 

66:写一单实例类要求精简，清晰? (单例抛式)

饿汉式单例：
   public class Singleton {
       private Singleton(){}
       private static Singleton instance = new Singleton();
       public static Singleton getInstance(){
           return instance;
       }
   }
懒汉式单例：
   public class Singleton {
       private static Singleton instance = null;
       private Singleton() {}
       public static synchronized Singleton getInstance(){
           if (instance == null)
               instance ＝ new Singleton();
           return instance;
       }
   }

 

67:构造器(constructor)是否可被重写(override)是否可被重载?是否可被继承？

构造器不能被继承，所以不能重写Override，但能够被重载Overload

 

68:JSP和Servlet有哪些相同点和不一样点，他们之间的联系是什么？

- jsp本质就是servlet
- jsp应用于页面显示，servlet应用于逻辑控制
- setvlet中没有内置对象，jsp中的内置对象都是必须经过HttpServletRequest对象，HttpServletResponse对象及HttpServlet对象获得

 

69:简述synchronized和java.util.concurrent.locks.Lock的异同？

- Lock能完成几乎全部synchronized的功能，并有一些后者不具有的功能，如锁投票、定时锁等候、可中断锁等候等
- synchronized 是Java内置的关键字，Lock 则是JDK 5中出现的一个包
- synchronized 同步的代码块能够由JVM自动释放；Lock 须要程序员在finally块中手工释放

 

70:解析xml和exce1分别使用什么技术?

xml-dom4j
excel-poi、jxl

 

71:如何发布spring boot项目，简述步骤?

发布JAR包、发布WAR包、部署到自动化容器中

 

72:什么是java序列化，如何实现java序列化?

概念：
   序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化（将对象转换成二进制）。能够对流化后的对象进行读写操做，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操做时所引起的问题
序列化：把Java对象转换为字节序列的过程。
反序列化：把字节序列恢复为Java对象的过程。
实现：
   将须要被序列化的类实现Serializable接口
注意：
   被关键字static、transient修饰的变量不能被序列化。在被序列化后，transient修饰的变量会被设为初始值。如int型的是0、对象型的是null.

 

73:在JAVA中，如何跳出当前的多重嵌套循环?

用break; return 方法。

 

74:面向对象的特征有哪些方面?

- 抽象：
   抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解所有问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
- 继承：
   继承是一种联结类的层次模型，而且容许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类能够从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类能够从它的基类那里继承方法和实例变量，而且类能够修改或增长新的方法使之更适合特殊的须要。
- 封装：
   封装是把过程和数据包围起来，对数据的访问只能经过已定义的界面。面向对象计算始于这个基本概念，即现实世界能够被描绘成一系列彻底自治、封装的对象，这些对象经过一个受保护的接口访问其余对象。
- 多态性：
   多态性是指容许不一样类的对象对同一消息做出响应。多态性包括参数化多态性和包含多态性。多态性语言具备灵活、抽象、行为共享、代码共享的优点，很好的解决了应用程序函数同名问题。

 

75: Collection和Collections的区别?

Collection是集合类的上级接口
继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各类集合的搜索、排序、线程安全化等操做。

 

76:同步和异步有何异同，在什么状况下分别使用他们?举例说明？

若是数据将在线程间共享。例如正在写的数据之后可能被另外一个线程读到，或者正在读的数据可能已经被另外一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个须要花费很长时间来执行的方法，而且不但愿让程序等待方法的返回时，就应该使用异步编程，在不少状况下采用异步途径每每更有效率

77:abstract class和interface有什么区别?

78:GC是什么?为何要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会致使程序或系统的不稳定甚至崩溃，
Java提供的GC功能能够自动监测对象是否超过做用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操做方法

 

 

79:请说出你所知道的线程同步的方法?

wait():使一个线程处于等待状态，而且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。 notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM肯定唤醒哪一个线程，并且不是按优先级。
Allnotity():唤醒全部处入等待状态的线程，注意并非给全部唤醒线程一个对象的锁，而是让它们竞争。

 

80:JSP的内置对象及方法?

request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，而且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各类范围的名字空间、servlet相关的对象的API，而且包装了通用的servlet相关功能的方法。 session表示一个请求的javax.servlet.http.HttpSession对象。
Session能够存贮用户的状态信息 applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息 config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page表示从该页面产生的一个servlet实例

 

 

81:如何现实servlet的单线程模式?

<%@ page isThreadSafe=”false”%>

 

82:面间对象传递的方法?

request，session，application，cookie等

 

83:Request对象的主要方法?

setAttribute(String name,Object)：设置名字为name的request的参数值
getAttribute(String name)：返回由name指定的属性值
getAttributeNames()：返回request对象全部属性的名字集合，结果是一个枚举的实例
getCookies()：返回客户端的全部Cookie对象，结果是一个Cookie数组
getCharacterEncoding()：返回请求中的字符编码方式
getContentLength()：返回请求的Body的长度
getHeader(String name)：得到HTTP协议定义的文件头信息
getHeaders(String name)：返回指定名字的request Header的全部值，结果是一个枚举的实例
getHeaderNames()：返回因此request Header的名字，结果是一个枚举的实例
getInputStream()：返回请求的输入流，用于得到请求中的数据 getMethod()：得到客户端向服务器端传送数据的方法
getParameter(String name)：得到客户端传送给服务器端的有name指定的参数值
getParameterNames()：得到客户端传送给服务器端的全部参数的名字，结果是一个枚举的实例
getParameterValues(String name)：得到有name指定的参数的全部值
getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
getQueryString()：得到查询字符串
getRequestURI()：获取发出请求字符串的客户端地址
getRemoteAddr()：获取客户端的IP地址
getRemoteHost()：获取客户端的名字
getSession([Boolean create])：返回和请求相关
Session getServerName()：获取服务器的名字
getServletPath()：获取客户端所请求的脚本文件的路径
getServerPort()：获取服务器的端口号
removeAttribute(String name)：删除请求中的一个属性

 

84:J2ee经常使用的设计模式?说明工厂模式?

Java中的23种设计模式：
Factory（工厂模式）， Builder（建造模式），
Factory Method（工厂方法模式）， Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
Adapter（适配器模式）， Bridge（桥梁模式），
Composite（合成模式）， Decorator（装饰模式），
Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解释器模式），
Visitor（访问者模式）， Iterator（迭代子模式），
Mediator（调停者模式）， Memento（备忘录模式），
Observer（观察者模式）， State（状态模式），
Strategy（策略模式）， Template Method（模板方法模式），
Chain Of Responsibleity（责任链模式）
工厂模式：工厂模式是一种常常被使用到的模式，
根据工厂模式实现的类能够根据提供的数据生成一组类中某一个类的实例，
一般这一组类有一个公共的抽象父类而且实现了相同的方法，可是这些方法针对不一样的数据进行了不一样的操做。
首先须要定义一个基类，该类的子类经过不一样的方法实现了基类中的方法。
而后须要定义一个工厂类，工厂类能够根据条件生成不一样的子类实例。
当获得子类的实例后，开发人员能够调用基类中的方法而没必要考虑到底返回的是哪个子类的实例。

 

85:List、Map、Set三个接口，存取元素时，各有什么特色?

List 以特定次序来持有元素，可有重复元素。
Set 没法拥有重复元素,内部排序。
Map 保存key-value值，value可多值。

 

86:如何对数据库作优化?

1：数据库设计
   数据库表：字段类型、字段长度、注释、字段命名规范
   数据库索引：外键、关联字段、查询频率比较高的字段、
           若是数据表字段>20，则最多支持16个索引
           若是数据表字段<20，则根据查询频率字段来定
   数据库视图：至关于一张临时表，业务中，尽可能少使用
   数据库引擎：根据业务，选择对应的表引擎技术
   数据库存储过程：尽可能少用
   数据库字符：UTF-八、或者和页面字符保持一致
   数据库监听器/触发器：通常用于调度任务或者备份还原
2：业务调用的sql语句优化
   xml：
   尽可能少关联表，效率最高关联4张表，若是多于4张表，则须要开启两个连接事务，可是这两个事务，必须在一个service当中。
   若是是查询语句，则不建议使用*
   若是是查询语句，where条件后面，最好使用索引字段进行关联
3：数据库服务器的搭建（集群）
   主从配置：
   读写分离：
   自动化（容器）：

 

87:如何对JVM进行性能调优?

 

88:如何实现集群模式下，session共享?

一：Tomcat自己配置
1：登陆成功以后，将session信息存放到redis中，利用拦截器来过滤查找session（推荐）
2：配置tomcat文件server.xml
<Engine name="Catalina" defaultHost="localhost" jvmRoute="8081">
<Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
若是尚未session信息同步，则须要在项目的启动容器web.xml中，在display-name标签下面，添加<distributable/>
二：使用redis服务器

 

89: 程序员若是想换行，应该怎么处理?

回车

90:公司若是想换一个灯泡，请问须要几个java工程师?

 

91: Hibernate一级缓存和二级缓存的区别?

一、  一级缓存是session独享，默认开启，无需配置

二、  二级缓存是session共享，须要在配置文件中开启，能够指定缓存区域块

92: Hibernate有几种查询方式?

HQL语句查询、Criteria查询、NativeSQL查询

93、解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。
答：一般咱们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM中的栈空间；而经过new关键字和构造器建立的对象则放在堆空间，堆是垃圾收集器管理的主要区域，因为如今的垃圾收集器都采用分代收集算法，因此堆空间还能够细分为新生代和老生代，再具体一点能够分为Eden、Survivor（又可分为From Survivor和To Survivor）、Tenured；方法区和堆都是各个线程共享的内存区域，用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据；程序中的字面量（literal）如直接书写的100、"hello"和常量都是放在常量池中，常量池是方法区的一部分，。栈空间操做起来最快可是栈很小，一般大量的对象都是放在堆空间，栈和堆的大小均可以经过JVM的启动参数来进行调整，栈空间用光了会引起StackOverflowError，而堆和常量池空间不足则会引起OutOfMemoryError。

1、下列说法正确的是(  )

A、java的数组能够随时改变大小

B、String字符串的长度和大小都是不可变的

C、boolean类型变量默认初始值为true（false）

D、Java虚拟机是实现跨平台的基础

 

2、下面代码运行结果为:( A )

      public static void main(String[] args){

     int  x = 1, y = 1, z = 1;

     if(x--==1&&y++==1  ||z++= =1) {

 System.out.println(“x=”+x+”,y=”+y+”,z=”+z;);

              }

}

   A: x=0,y=2,z=1                        B: x=1,y=2,z=1

   C: 没有输出                D:x=0,y=2,z=2

 

3、下列没有语法编译错误的是：(   )

A.  public static void main(String[] args){

  byte  b1 =  1;

         byte  b2 =  2;

      byte  b =  b1+b2;

  }

B.  public static void main(String[] args){    

         int n = 100;

       while(n>0){

System.out.println(n);

   }

   }

C.  public static void main(String[] args){    

 int n;

        for(int i = 0;i<10;i++){

    n+= i ;

         }

}

        D.  public static void main(String[] args){          

int n = 100;

        for(;;){

           }

        System.out.println(n);

   } 

 

4、如下程序的输出结果为（C）

public  class  Test{

public  static  void  main (String[] args){

int[]  a = {1,2,3,4,5};

int[]  b = change(a);

b[1]  = 7;

System.out.println(a[1]);

}

public  static  int[]  change(int[]  a){

a[1] = 6;

return  a ;

}

}

A、编译错误    B、运行出错   C、6   D、7

 

5、对于构造函数,下列叙述不正确的是（C）

A、构造函数是类的特殊函数，他的方法名必须与类名相同

B、构造函数没有返回值类型

C、一个类能够有多个构造函数

D、构造函数在类加载时调用

 

6、给定java代码以下：

  class Parent{

      int i=2;

      public Parent() {

           System.out.println("parent");

      }

}

class Child extends Parent{

      int i=5;

      public Child() {

           System.out.println("child");

      }

}

public class Test {

      public static void main(String[] args) {

           Parent p = new Child();

           System.out.println(p.i);

      }

}

   运行编译后，输出结果为(    )

   A. child 2       B. child 5   C.parent child 2   D.parent child 5

7、如下程序的输出结果为：（）

class  ClassA{

int  value;

}

public  class  TestClassA{

public  static  void  main(String[]  args){

int  value = 10;

changeInt(value); 

System.out.println(value); 

 

ClassA  ca = new  ClassA();

ca.value = 10;

changeObject(ca);

System.out.println(ca.value);

}

public  static  void  changeInt(int  value){

++value;

}

public  static  void  changeObject(ClassA  ca){

ca.value++;

}

}

A.编译不经过         B.10,11          C. 10,10         D. 11,11

 

8、阅读如下代码，能正确删除全部”java”的是: ( B)

public class Test1 {

      public static void main(String[] args) {

           List<String> list = new ArrayList<>();

           list.add("aa");

           list.add("java");

           list.add("bb");

           list.add("java");

           list.add("java");

      }

}

A、     for(int i=0;i<list.size();i++){

           if("java".equals(list.get(i))){

                 list.remove(i);

           }

      }

B、for(int i=list.size()-1;i>=0;i--){

                 if("java".equals(list.get(i))){

                      list.remove(i);

                 }

      }

C、list.remove(“java”);

D、list.removeAll(“java”);

 

9、下面程序的输出结果为( )

public class Test {

      public static String outPut="";

      public static void foo(int i){

           try {

                 if(i==1)

                      throw new Exception();

                 outPut+="1";

           } catch (Exception e) {

                 outPut+="2";

                 return;

           }finally{

                 outPut+="3";

           }

           outPut+="4";

      }

      public static void main(String[] args) {

           foo(0);

           System.out.println(outPut);

           foo(1);

           System.out.println(outPut);

      }

}

A、134  13423    B、1  134    C、134  34    D、134  134134

 

10、下面程序的输出结果为( )

class T1{

      int i=0;

      public void Test1(){

           System.out.println(i);

      }

      public void Test2(){

           System.out.println(i);

      }

}

class T2 extends T1{

      int i=2;

      public void Test2(){

           System.out.println(i);

      }

}

public class TestCase {

      public static void main(String[] args) {

           T1 test = new T2();

           test.Test1();

           test.Test2();

           System.out.println(test.i);

           test = (T2)test;

           System.out.println(test.i);

      }

}

A、0  0  0  0     B、0  2  0  0   C、0  2  2  2     D、编译不能经过 

2、问答题(每题5分,共60分)

1、描述你所理解的java中抽象类和接口的概念

2、简述面向对象的特征以及做用

3、HashMap和HashTable有什么区别,ArrayList和LinkedList?

4、拦截器和过滤器的应用场景是什么,有什么区别

拦截器和过滤器的区别：

一、过滤器是依赖于Servlet容器，拦截器不依赖于容器

二、过滤器是能够拦截全部请求，拦截器只针对Action起做用

三、过滤器只在容器初始化执行一次，拦截器能够屡次执行

四、过滤器不能访问值栈中的对象，拦截器能够访问值栈中的对象

五、过滤器底层实现：回调

拦截器底层实现：反射

 

5、如何理解设计模式,用代码写出一种你最熟悉的设计模式

6、cookie和session的做用,区别以及应用场景,分别用图画出工做原理？

cookie和Session

状态管理:

web应用程序是基于HTTP协议的，而HTTP协议是无状态的协议，无状态也就是说一次请求，一次响应以后即断开链接，而同一个用户的下一次请求须要从新创建链接，但在有时候服务器须要判断是否为同一个用户的屡次操做，因此这些时候须要将用户的屡次请求当作说一个总体来看待，而且将屡次交互涉及到的数据进行保存下来

状态：交互产生的数据

管理：屡次交互对数据的修改

实现状态常见的有两种方式

cookie：浏览器客户端状态管理，将状态保存在浏览器客户端

session：服务器状态(数据)管理，将状态保存在服务器

Cookie：实现原理

一、浏览器客户端第一次访问服务器端返回响应数据时，响应数据包中以Set-Cookie消息头方式给浏览器返回cookie信息

Set-Cookie：name=张三

Set-Cookie：count =10；

二、浏览器接受服务器端的响应数据包以后，解析响应数据包，获取cookie信息，保存在客户端

三、客户端在后续每一次访问时，须要携带保存cookie，以cookie请求消息头方式发给服务器

cookie：name=张三，count=10

四、服务器接受请求以后，获取请求数据包中cookie信息进行操做，完成HTTP状态管理

Session

一、客户端发送第一次请求，服务器端会建立一个session对象，把相关的数据存储到session中，并给该对象分配一个32位的惟一id，通常称之为JSESSIONID

二、在服务器第一次给客户端返回响应时，把JESSIONID以Set-Cookie消息头方式带回给浏览器客户端

Set-Cookie：JESSIONID=xxxx

三、在客户端接受到响应数据包以后，解析出JESSIONID以cookie形式存储在浏览器客户端

四、在后续浏览器客户端每一次发送请求时，以Cookie消息头方式把JESSIONID发送给服务器

Cookie：JESSIONID=xxxx

五、服务器获取JESSIONID后，根据JESSION去找相应的session 对象，完成状态管理

 

7、什么是MVC,说下你对MVC的理解？

8、struts2和springmvc比较有什么共同点和不一样点,分别画出执行流程图

9、什么是IOC和AOP,底层实现原理分别是什么？

IOC：Inversion of Control 控制反转

改变对象的建立方式，由最初的new方式建立对象，转变为由spring容器去建立和管理。下降对象之间的耦合度；IOC是整个spring框架的核心，spring其余全部功能都是基于IOC基础之上完成的。

DI：Denpency Injection 依赖注入

一、DI做用是维护对象之间的关系，将一块儿工做具备关系的对象经过构造器或者set方法传入值创建关系。

二、IOC是一种思想，DI是实现IOC思想的途径

AOP：Aspect Oriented Programming 面向切面编程

将一个系统中公用的业务逻辑进行提取出来，单独封装成一个组件(切面)，而后再以配置的方式做用到系统中，实现程序的可插拔性，提升代码复用，提高系统性能。

AOP底层实现原理

动态代理模式：能够根据一个类去动态的生成另一个类，代理类会拥有委托类的API方法。

 

 

10、Hibernate对象有哪些状态,怎么转换

Hibernate对象有三种状态，分为：

一、  临时态：内存中有对象，数据库没有与之对应的数据，新建的对象也是临时状态，持久状态的对象调用了delete()方法也会变成新建状态；

二、  持久态：内存中有对象，数据库有与之对应的数据，修改对象的属性，数据库中数据也会跟着修改。持久状态的对象存在于内存的session缓存区域。

2.1>新建状态调用了save()或者saveOrUpdate()会变成持久状态

2.2>经过id从数据库get()或者load()出来的对象也是持久态的对象

2.3>游离态对象调用了save()或者saveOrUpdate()方法也会变成持久态

三、游离态

内存中有对象，数据库中有之对应的数据，可是对象处于离线状态，修改对象的属性，数据库数据不会修改

11、简述事物隔离级别,传播特性,脏读,幻读,不可重复读分别是什么意思？

事务的特性：

一、  原子性（Atomicity）二、一致性（Consistency）三、隔离性（Isolation）四、持久性（Durability）

事务的隔离级别：事务的隔离级别也分为四种，由低到高依次分别为：read uncommited（读未提交）、read commited（读提交）、read repeatable（读重复）、serializable（序列化），这四个级别能够逐个解决脏读、不可重复读、幻读这几类问题。

1.read uncommited：是最低的事务隔离级别，它容许另一个事务能够看到这个事务未提交的数据。

2.read commited：保证一个事物提交后才能被另一个事务读取。另一个事务不能读取该事物未提交的数据。

3.repeatable read：这种事务隔离级别能够防止脏读，不可重复读。可是可能会出现幻象读。它除了保证一个事务不能被另一个事务读取未提交的数据以外还避免了如下状况产生（不可重复读）。

4.serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读以外，还避免了幻象读。

脏读：指当一个事务正字访问数据，而且对数据进行了修改，而这种数据尚未提交到数据库中，这时，另一个事务也访问这个数据，而后使用了这个数据。由于这个数据尚未提交那么另一个事务读取到的这个数据咱们称之为脏数据。依据脏数据所作的操做是不正确的。

幻读：一个事务前后读取一个范围的记录，但两次读取的纪录数不一样，咱们称之为幻象读（两次执行同一条 select 语句会出现不一样的结果，第二次读会增长一数据行，并无说这两次执行是在同一个事务中）

不可重复读：指在一个事务内，屡次读同一数据。在这个事务尚未执行结束，另一个事务也访问该同一数据，那么在第一个事务中的两次读取数据之间，因为第二个事务的修改第一个事务两次读到的数据多是不同的，这样就发生了在一个事物内两次连续读到的数据是不同的，这种状况被称为是不可重复读

Spring事务传播特性：

事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持支持7 种事务传播行为：

propagation_requierd：若是当前没有事务，就新建一个事务，若是已存在一个，加入到这个事务中，这是最多见的选择

propagation_supports：支持当前事务，若是没有当前事务，就以非事务方法执行。

propagation_mandatory：使用当前事务，若是没有当前事务，就抛出异常。propagation_required_new：新建事务，若是当前存在事务，把当前事务挂起。propagation_not_supported：以非事务方式执行操做，若是当前存在事务，就把当前事务挂起。把当前事务挂起。

propagation_never：以非事务方式执行操做，若是当前事务存在则抛出异常。propagation_nested：若是当前存在事务，则在嵌套事务内执行。若是当前没有事务，则执行与propagation_required相似的操做相似的操做

Spring 默认的事务传播行为是默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情，它适合于绝大多数的状况。假设 ServiveX#methodX() 都工做在事务环境下（即都被 Spring 事务加强了），假设程序中存在以下的调用链： Service1#method1()->Service2#method2()>Service3#method3()，那么这，那么这 3 个服务类的 3 个方法经过 Spring 的事务传播机制都工做在同一个事务中

12、有哪些方式能够提升数据库的查询效率？

1.创建适当的索引

2.避免在索引上使用计算

3.避免在索引列上使用NOT

4.避免在索引上使用IS NULL 和 IS NOT NULL

5.避免没必要要的行和列

6．Select 子句中避免使用 *

7.在IN后面值的列表中，将出现最频繁的值放在最前面，出现最少的放在最后，减小判断次数。

8.使用batch处理

9.注意Union和Union all的区别

10.Where子句中的链接顺序

11.DISTINCT的使用：注意，在数据量大的时候，尽可能不要使用，它同UNION同样会使查询变慢。由于Oracle须要对后面的全部字段进行排序，消耗性能。

13、有2个空水壶,容积是5升和6升,怎样才能利用这2个空水壶从水池中取出3升的水？

将6升水倒入5升的，6升剩下1升；把1升水放入到5升壶中，再用6升壶水倒入放有1升水的5升壶，6升壶剩余2升；把这2升水在倒入5升壶，再用6升壶倒入5升壶，6升的壶就剩余3升水；

 

 

 

              SSH、SSM框架测试题

                         --将答案写在答题纸上

1、Struts2的执行流程是什么

struts2执行流程(重点）

一、浏览器向服务器发起请求

二、请求首先会被提交到web.xml中定义的前端过滤器filter中

三、前端过滤器解析请求路径，在根据struts.xml文件中的配置，决定将这个请求交给哪个action进行处理，而且指定交由哪个业务方法进行处理

四、业务方法处理完请求以后，会给前端过滤器返回一个字符串

五、前端过滤器拿到字符串以后在根据struts.xml中result配置找到相应的页面而后在进行返回

 

2、值栈和OGNL做用分别是什么？

一、值栈是什么

Struts2中的数据中心，主要存储与当前Action相关的数据和信息

--当前action对象

--action中定义的属性(有set／get方法)

--action中定义的域对象：request，session，application

二、值栈的做用

Action向页面传输值的缓存区

三、值栈到存值区域

root区（list区域）：以栈结构形式存储当前Action中的属性以及直接往栈中push的元素

context区（map区域）：主要存储与当前Action相关的域对象信息

request，session，application

四、OGNL

Struts2中定义的一种表达式语言，主要用于能够从值栈中取值

4.一、引入Struts2的标签库

4.二、从root区域取值

<s:property value="属性名"/>

靠近栈顶到同名会被先取出来，而后就再也不往下查询

4.三、从context区域取值

<s:property value="#域对象.key值"/>

3、Struts中JSP如何给Action传值

 

一、在Action中经过ServletActionContext获取到request对象，而后调用request.getParameter("key值")

二、属性注入

2.一、请求参数key值（通常是表单name值），必须和action中定义的属性名保持一致

2.二、action中属性提供set/get方法。

三、域模型传值

针对表单中请求参数较多

3.一、建立一个实体类，根据表单中提交项定义属性，属性要提供set/get方法

3.二、在action中定义一个实体类对象属性，属性提供set/get方法

3.三、表单中的提交项name属性中为action实体对象名.实体类属性名

如：name="user.username"

name="user.password"

 

4、拦截器的做用,以及拦截器和过滤器之间的区别?

Struts2中定义的对Action进行动态拦截的对象，拦截器中的方法会在Action调用先后都会执行，也能够经过动态设置来阻止Action执行。

拦截器的做用：封装代码通用逻辑，以便于重复利用，如：登录验证，日志记录，权限控制；并且拦截器能够经过动态配置来使用，提供系统灵活性，实现解耦合。

拦截器和过滤器的区别：

一、过滤器是依赖于Servlet容器，拦截器不依赖于容器

二、过滤器是能够拦截全部请求，拦截器只针对Action起做用

三、过滤器只在容器初始化执行一次，拦截器能够屡次执行

四、过滤器不能访问值栈中的对象，拦截器能够访问值栈中的对象

五、过滤器底层实现：回调

拦截器底层实现：反射

 

5、IOC是什么,底层如何实现的,IOC与DI之间关系

IOC：Inversion of Control 控制反转；改变对象的建立方式，由最初的new方式建立对象，转变为由spring容器去建立和管理，下降对象之间的耦合度。IOC是整个spring框架的核心，spring其余功能都是基于IOC基础上完成的。

DI:Denpency Injection 依赖注入，DI的做用是维护对象之间的关系，将一块儿工做具备关系的对象经过构造器或者set方法传入值创建关系。

IOC是一种思想，DI是实现IOC思想的途径

 

6、AOP做用是什么,底层如何实如今哪些地方会用到,分别简述切面切入点和通知

Aspect Oriented Programming 面向切面编程

将一个系统中公用的业务逻辑进行提取出来，单独封装成一个组件(切面)，

而后再以配置的方式做用到系统中，实现程序的可插拔性，提升代码复用，

提高系统性能。

2、AOP底层实现原理

动态代理模式：能够根据一个类去动态的生成另一个类，代理类会拥有

委托类的API方法。

JDK动态代理(只支持接口注入)

CGLIB动态代理(能够支持普通类注入)

3、AOP和OOP区别

一、AOP是以OOP为基础

二、OOP侧重于对象的封装，AOP侧重于共通业务逻辑的封装

4、AOP使用方式

一、切面：Aspect

系统中共通业务逻辑的封装，会在某个时刻或者阶段共通调用，强调

调用时机相同，如：事务处理，异常处理，日志，安全验证，权限验证

二、切入点：PointCut

切入点目标：给谁追加共通处理

在spring中提供切入点表达式(正则表达式)

1>名称限定表达式(切入到方法)

语法：execution(修饰符？ 返回值类型|* 方法名|*(参数列表|..))

2>类型限定表达式(切入到某一个类)

语法：within(类型)

三、通知advice

何时调用共通的业务逻辑

主要用于指定切面做用到切入点上的时机

在spring中提供了五种类型通知

1>前置通知-->目标方法调用前 @Before

2>后置通知-->目标方法调用后 @AfterReturning

3>异常通知-->目标方法产生异常后调用 @AfterThrowing

4>最终通知-->目标方法进行finally调用 @After

5>环绕通知-->目标方法调用先后都会执行 @Around

环绕通知=前置通知+后置通知

 

7、什么是动态代理模式

8、什么是spring容器

在Spring框架中，全部的Java类和JavaBean对象都会被看成是一个bean组件，这些bean组件都是由spring容器负责管理和建立以及维护这些对象之间的关系。

 

9、spring如何管理Bean对象

一、管理对象的实例化(最经常使用)

构造器构建对象

<bean id="" class=""></bean>

静态工厂构建对象

<bean id="" class="" factory-method=""></bean>

实例工厂构建对象

<bean id="" factory-bean="" factory-method=""></bean>

二、管理对象的做用域

scope="singleton"默认，单例模式，每次调用getBean()返回同一个对象

scope=“prototype”每次调用getBean()返回一个新的对象

三、管理对象的生命周期

init-method=“”bean组件的初始化方法，

在bean组件实例化完成后自动调用，

destroy-method=""bean组件销毁方法，单例bean组件在容器关闭时调用

四、延迟实例化对象

在spring容器中全部的单例bean默认在容器启动时构建对象

lazy-init=“true”将单例对象实例化时机延迟到调用getBean()方法时调用

lazy-init="false"默认值，容器启动构建单例对象

 

10、什么是Restful,如何编写一个Restful风格的springMvC项目

一、Restful

表现层状态转移，是一个软件设计风格，主要是用于对网络上的资源进行统必定位以及规定统一操做的方式

二、网络上的资源(核心)

1>网络上的全部数据均可以抽象为资源，Restful能够对资源进行标识

2>不管以任何方式来操做这个资源都不会影响资源标识

三、Restful优势

1>下降程序复杂性

2>提升程序的可伸缩性

四、SpringMVC对Restful的支持

1>统一规定网络上资源的标识

2>统一规定访问资源的方式

 

五、如何编写Restful风格的SpringMVC应用

1>将前端过滤器中请求路径url-pattern改成/

DispatcherServlet当拦截到请求以后，会将请求拿到映射器中作匹配，匹配上了进入处理器，匹配不上之间返回404，不会去找静态页面

解决问题：将*.do改成/以后，webContent目录下HTML/css/js/image等等静态资源没法访问

<mvc:resources location="" mapping=""/>

<!-- SpringMVC框架本身处理静态资源，静态资源能够放在任意目录下 -->

<mvc:default-servlet-handler/>

<!-- 对请求URL进行判断，访问静态资源的交给Servlet容器处理，其余的交给映射器处理

静态资源必须在WebContent目录下

-->

2>导入SpringMVC对Ajax的支持包，借助Ajax客户端向服务器发送DELETE，PUT请求

3>在Controller中经过@RequestMapping注解，添加要处理的请求URL模板和Http请求的动做类型

4>利用@PathVariable注解将URL上的变量映射处处理方法的参数上

 

11、用过哪些数据库链接池,有什么区别

一 开源数据链接池
1 dbcp
dbcp多是使用最多的开源链接池，缘由大概是由于配置方便，并且不少开源和tomcat应用例子都是使用的这个链接池吧。
这个链接池能够设置最大和最小链接，链接等待时间等，基本功能都有。这个链接池的配置参见附件压缩包中的:dbcp.xml
使用评价：在具体项目应用中，发现此链接池的持续运行的稳定性仍是能够，不过速度稍慢，在大并发量的压力下稳定性
有所降低，此外不提供链接池监控

2 c3p0
c3p0是另一个开源的链接池，在业界也是比较有名的，这个链接池能够设置最大和最小链接，链接等待时间等，基本功能都有。
这个链接池的配置参见附件压缩包中的:c3p0.xml。
使用评价：在具体项目应用中，发现此链接池的持续运行的稳定性至关不错，在大并发量的压力下稳定性也有必定保证，
          此外不提供链接池监控。

12、MyBatis中${}和#{}有什么区别？

一、#先编译，而后在传值，传的值都是字符串;$直接拼接字符串

二、$会形成SQL注入，#不会

三、传入表名和列名能够用$

四、传入值的时候必须使用#，不要使用$

13、Spring中AutoWired和Resource之间区别是什么?

@AutoWired:spring框架自带注解

先按照类型进行匹配，若是存在多个匹配的类型会报错

@Resource：JavaEE中注解

推荐使用，解耦合；按照名称进行注入，查看spring容器中是否有bean对象的id值和引用名同样，

若是按照名称查找不到bean组件，就按照类型注入。

若是在容器中有多个匹配，能够强制按照名称注入。

@Autowired

@Qualifier("匹配的id值")或者@Resource(name="id值")；

 

14、Hibernate中延迟加载是什么,如何实现,如何取消？

 

延迟加载：lazy load 懒加载

在尽量晚的状况下，真正须要使用到数据的时候，才会向数据库发送sql语句执行查询，加载

数据到内存中，避免了无谓的性能开销。

load()延迟加载：不发送SQL语句，而默认返回一个代理对象，只保存对象的ID值。

get()取消延迟加载：发送SQL语句，可是只会查询当前对象的完整信息，若是当前对象还有关

联的集合数据或者对象，默认都是延迟加载，不会发送SQL语句去查询其关联的对象或集合。

 

15、Hibernate的二级缓存和MyBatis二级缓存区别？

Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外，均可以经过实现你本身的缓存或为其余第三方缓存方案，建立适配器来彻底覆盖缓存行为。

不一样点：Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置；MyBatis的二级缓存配置都是在每一个具体的表-对象映射中进行详细配置，这样针对不一样的表能够自定义不一样的缓存机制。而且Mybatis能够在命名空间中共享相同的缓存配置和实例，经过Cache-ref来实现。

二者比较：由于Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。因此在使用二级缓存时若是出现脏数据，系统会报出错误并提示。

而MyBatis在这一方面，使用二级缓存时须要特别当心。若是不能彻底肯定数据更新操做的波及范围，避免Cache的盲目使用。不然，脏数据的出现会给系统的正常运行带来很大的隐患。

Hibernate与MyBatis均可以是经过SessionFactoryBuider由XML配置文件生成SessionFactory，而后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。

而MyBatis的优点是MyBatis能够进行更为细致的SQL优化，能够减小查询字段，而且容易掌握。

Hibernate的优点是DAO层开发比MyBatis简单，Mybatis须要维护SQL和结果映射。数据库移植性很好，MyBatis的数据库移植性很差，不一样的数据库须要写不一样SQL。有更好的二级缓存机制，能够使用第三方缓存。MyBatis自己提供的缓存机制不佳。

 

16、Hibernate和MyBatis中分别是如何实现表之间的关联查询？

Hibernate：建立关联映射，在映射文件中的加入维持关系的外键名称

Mybatis：建立关联映射，在映射文件中添加多方集合属性名

17、Spring如何管理事物,事物的传播特性和隔离级别有哪些？

Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。

事物的传播特性：

一、原子性：指事物包含全部的操做要么彻底成功，要么彻底失败，事物的操做若是成功就必需要彻底应用到数据库，若是失败就不能对数据库有任何的影响

二、一致性：指事物必须使数据库从一个一致性变换到另外一个一致性，也就是说一个事物执行以前和执行以后都必须处于一个一致性状态。

三、隔离性：是当多个用户一块儿访问数据库时，操做同一个数据时，数据库为每个用户开启事物，每一个用户不被其余用户的事物影响干扰，多个并发事物之间要相互隔离。

四、持久性：指一个事物一旦被提交了，那么数据库的改变就是永久性的。即使是在系统遇到故障的状况下也不会丢失提交事物的操做。

隔离级别：

一、Serializable（串行化）：可避免脏读，不可重复读，幻读的发生。

二、Repeatable read(可重复读)：可避免脏读、不可重复读的发生。

三、Read committed(读已提交)：可避免脏读的发生。

四、Read uncommitted(读未提交)：最低级别，任何状况都没法保证。

最高级别的事Serializable级别，最低的是Read uncommitted级别。Mysql数据库中默认的隔离级别为Repeatable read（可重复读）

 

18、Struts如何实现文件上传下载.如何限制上传文件的大小和类型？

一、建立一个文件上传表单；表单提交方式为post，表单编码ectype=‘multipart/form-data'

限制文件上传大小

单个action：<param name="maximumSize">52428800</param>

整个项目设置：<constant name="struts.multipart.maxSize" value="2097152000"></constant>

 

19、Hibernate中对象的状态有哪些,他们之间是如何转换

一、临时态（瞬时态）：内存中有对象，数据库中没有与之对应的数据，新建的对象是临时状态，持久态的对象调用了delete()方法也会变成新建状态。

二、持久态：内存中有对象，数据库中有与之对应的数据，修改对象的属性，数据库中数据也会发生改变。持久状态的对象存在于内存的session缓存区域。

   新建状态调用了sava()或者saveOrUpdate()会变成持久状态。

   经过id从数据库get()或者load()出来的对象也是持久状态对象

   游离态对象调用save()或者saveOrUpdate()方法也会变成持久状态

三、游离态：内存中有对象，数据库有之对应的数据，可是对象处于离线状态，修改对象数据库中数据不会修改。

   Session关闭

清空session缓存

从session中剔除某个持久态对象

20、SpringMvc中的执行流程是什么,与Struts有什么区别？

一、页面向服务器发起请求，页面被提交到前端控制器

二、前端控制器接受到请求后调用处理器映射器HandlerMapping，映射器根据请求路径和映射规则找到相应的处理器Handler

三、前端控制器会根据映射器找到相应的处理器类型调用对应的设配器，适配器在调用处理器的业务方法

四、处理器中业务方法处理请求流程，处理完成以后会返回一个ModelAndView对象给处理器适配器

五、处理器适配器再将ModelAndView对象返回给前端控制器

六、前端控制器拿到ModelAndView对象以后取出其中的视图名称，在调用试图解析器找到相应的页面

七、在取出ModelAndView对象以后取出其中的视图名称，在调用视图解析器找到相应的页面

八、将JSP响应页面返回给客户端

21、SpringMvc适配器映射器和适配器处理做用分别是什么？他们之间有什么关系？

适配器映射器：根据请求路径以及映射规则找到对应的handler处理器

适配器：根据映射找到的处理器类型，调用不一样的适配器，适配器去调用处理器中方法；

注解的映射器和适配器要配对使用

22、视图解析器的做用是什么？

前端控制器取出ModelAndView对象中的视图名称，在根据试图解析器中配置找到相应的试图页面

23、SpringMvc如何防止中文乱码问题？

一、自定义过滤器实现Filter接口，在相应的业务方法中对中文进行处理

二、使用spring框架自带的过滤器CharacterEncodingFilter

24、Struts2中如何给前端页面返回一个JSON字符串

用于向请求发起端返回一个JSON类型的字符串

<result-type name="json" class="org.apache.struts2.json.JSONResult"/>

一、引入一个插件： struts2-json-plugin-2.1.8.jar

二、package的extends必须继承json-default

三、result类型

<result name="success" type="json"></result>

四、在Action中定义的只要提供了set/get方法都会以json格式进行返回

五、若是只想返回Action中部分数据，将须要返回的数据存入到map中

<result name="success" type="json">

<param name="root">map</param>

</result>

 

25、Hibernate中get和load方法有什么区别？

一、load()方法启用延迟加载机制来进行查询，若是只调用load方法会返回一个代理对象，对象中只保存了id，不会向数据库发送sql语句，只有当访问了对象的非id属性时，才会向数据库发送sql语句；

二、get()方法只要调用了就会向数据库发送sql语句，查询完成后将对象信息返回来

注：根据id查不到对象：load方法会返回ObjectNotFoundException，get返回null；

26、如何编写HQL语句,他与SQL语句有什么异同点？

hql格式：from + 类名 + 类对象 + where + 对象的属性

sql是面向数据库表查询，格式：from + 表名 + where + 表中字段

HQL是一种面向对象的查询语言，面向Java实体类，与SQL语句没有关系，可是和SQL语句有相同的语法结构；

异同：

SQL面向数据库查询，HQL面向Java实体类查询

HQL中不支持SELECT*的写法。

SQL不支持除了分组函数（聚合函数，组函数）之外的其余函数。

HQL语句不支持表的链接查询。

占位符使用，下标从0开始；

27、在SSH整合中如何实现分页查询,如何使用二级缓存？

 

28、列举出Spring中经常使用注解

普通bean组件：@Component

三个衍生注解：@Repository  @Service  @Controller

管理bean对象生命周期注解：@PostConstruct 初始化方法  @PreDestory 销毁方法

管理bean对象做用域注解：@Scope

DI依赖注入：普通值注入：@Value

引用类型值的输入：@AutoWired（spring自带）@Resource（JavaEE自带）

@Qualifier

29、SpringMvc中处理器和JSP页面之间怎样传值

JSP页面传值给Controller处理器：

一、在方法中添加HTTPServletRequest对象

二、在方法中添加参数接受jsp传过来的值

   1．请求参数key和方法参数名一致，直接将值传给参数

   2.请求参数key和方法参数名不一致，利用@RequestParam（）注解

三、使用实体类对象接受请求参数

   1．建立实体类，实体类属性名和请求参数key名称一致

   2.在业务方法添加实体对象做为参数，经过实体接受请求参数

Controller处理器传值给JSP页面：

一、在方法中添加HttpServletRequest对象或者session对象

二、在业务方法中添加Model对象或者ModelMap对象，实质上是将值存在request中

三、在参数前添加@ModelAttribute

30、Ajax与SpringMvc之间怎样进行数据交互

Ajax:异步提交，页面无刷新

一、引入SpringMvc与Ajax交互核心开发包

jackson-annotations-2.9.2.jar

jackson-core-2.9.2.jar

jackson-databind-2.9.2.jar

二、SpringMvc怎么传值给Ajax

再返回值类前面或方法上加注解@ResponseBody，这样返回的数据就不会走视图解析器，

而是直接返回前端Ajax，前端Ajax会将拿到的数据解析为与JS相对应的类型

String-->string

boolean-->boolean

bean对象-->object(JSON对象)

List-->object(Array)

map-->object(JSON对象）

三、Ajax怎么提交值给SpringMvc

一、提交普通请求实体字符串类型到springmvc，springmvc能够直接接受

key1 = varlue&key2 = value2&....

二、提交JSON字符串到spring，须要在方法参数中加@RequestBody注解

'{"key1":value1,"key2":value2....}'

三、怎样将表单中数据序列化为JSON字符串

1.导入js/jquery.serializeJson-min.js

2.将表单中数据序列化成json对象

var requestData = $("form").serialize();

3.把json对象序列化成json字符串

var jsObj = JSON.stringify(jsonObj);

 

31、SpringMvc如何处理静态资源文件

32、SpringMvc中拦截器如何编写,它与Struts中拦截器有什么区别？

写一个类实现HandlerInterceptor接口

重写接口中拦截方法：

   preHandler 请求进入处理器以前调用

   afterCompletion   处理器执行完请求以后调用

   postHandle    响应返回给浏览器以前调用

33、SpringMvc对异常的处理方式有哪些？

一、try{}catch{}

二、全局异常处理器（处理全部controller抛出的异常）

   添加全局异常处理器，统一处理项目中异常

三、局部异常处理器（只能处理当前处理器中的异常）：

   在当前的处理器中定义一个处理器异常的方法，在方法中添加Exception参数接受异常

   在处理方法上添加@ExceptionHandler注解

34、SpringMvc如何返回重定向与转发类型视图

一、转发到一个JSP页面

   返回值String：return“视图名”；

35、Struts2与SpringMvc有什么异同点？

一、Struts2是类级别的拦截， 一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,因此说从架构自己上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，由于Struts2中Action的一个方法能够对应一个url，而其类属性却被全部方法共享，这也就没法用注解或其余方式标识其所属方法了。

二、由上边缘由，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据经过参数获取，处理结果经过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其全部Action变量是共享的，这不会影响程序运行，却给咱们编码 读程序时带来麻烦，每次来了请求就建立一个Action，一个Action对象对应一个request上下文。
三、因为Struts2须要针对每一个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每一个Action使用，并保证线程安全，因此在原则上，是比较耗费内存的。

四、 拦截器实现机制上，Struts2有以本身的interceptor机制，SpringMVC用的是独立的AOP方式，这样致使Struts2的配置文件量仍是比SpringMVC大。

五、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不一样的。之前认为filter是servlet的一种特殊），这就致使了两者的机制不一样，这里就牵涉到servlet和filter的区别了。

六、SpringMVC集成了Ajax，使用很是方便，只需一个注解@ResponseBody就能够实现，而后直接返回响应文本便可，而Struts2拦截器集成了Ajax，在Action中处理时通常必须安装插件或者本身写代码集成进去，使用起来也相对不方便。

七、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感受太烦乱。

八、Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（固然Struts2也能够经过不一样的目录结构和相关配置作到SpringMVC同样的效果，可是须要xml配置的地方很多）。

九、 设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。

十、SpringMVC开发效率和性能高于Struts2。
十一、SpringMVC能够认为已经100%零配置。

 

 

36、Hibernate与MyBatis有什么异同点

（1）Hibernate与MyBatis都是经过SessionFactoryBuider由XML配置文件生成SessionFactory，由SessionFactory 生成Session，由Session来开启执行事务和SQL语句。

（2）Hibernate和MyBatis都支持JDBC（Java DataBase Connectivity，java数据库链接）和JTA（Java Transaction API，Java事务API（Application Programming Interface，应用程序编程接口））事务处理。

注：jdbc和jta的主要做用是加强数据访问能力。

（3）基于ORM（Object Relational Mapping， 对象关系映射）思想解决了entity和数据库的映射问题

不一样点：

（1）sql方面：mybaits经过mapper.xml维护映射结果，程序员手动编写sql相比hibernate自动生成hql（hibernate sql）更加灵活，sql调优更加容易（hibernate由于更好的封装性，开发效率提升的同时，sql语句调优要更费力，固然能够手动修改sql来优化，可是同时也会影响开发效率）；hibernate的hql数据库移植性更好，体如今强壮性。hibernate在级联删除的时候效率低；数据量大， 表多的时候，基于关系操做会变得复杂。

（2）缓存方面：mybatis和hibernate均可以使用第三方缓存，而hibernate相比maybatis有更好的二级缓存机制。

 

37、MyBatis接口映射规则

根据必定的映射规则，根据接口经过动态代理方式自动生成它的实现类

映射规则：

一、映射接口的全限定名必须和映射文件的namespace保持一致

二、映射接口中方法名必须和SQL定义语句的id保持一致

三、映射接口的方法的参数类型和SQL定义的parameterType保持一致

四、映射接口的返回值类型必须和SQL定义的resultType一致

update/delete/insert 返回值类型为void

 

建议规范

一、映射接口名后缀最好以Mapper结尾

二、映射文件放在与映射接口相同的包下面

 

38、Jquery如何发送Ajax请求

ajax() 方法经过 HTTP 请求加载远程数据。

该方法是 jQuery 底层 AJAX 实现。简单易用的高层实现见 $.get, $.post 等。$.ajax() 返回其建立的 XMLHttpRequest 对象。大多数状况下你无需直接操做该函数，除非你须要操做不经常使用的选项，以得到更多的灵活性。

最简单的状况下，$.ajax() 能够不带任何参数直接使用。

 

39、JS中经常使用数据类型有哪些

1.number          2.string    3.boolean         4.undefined      5.null        6.Object     7.symbol

40、JS对象的建立方式有哪些,如何将一个JS对象转换为JSON字符串?

建立对象的方式：

（1）、直接new对象

var obj = new Object（）；

//定义属性

obj.属性名= 属性值

//定义方法

obj.方法名= function（）{}

（2）、使用构造器构建对象

function Point（x，y）{

//属性

this.x= x;

this.y=y;

//方法

this.方法名=function（）{}

}

（3）、定义JSON格式的JS对象

var obj = {

属性名：属性值，

方法名：方法体

}；

将JSON字符串转换为JS对象

var obj = JSON.parse(jsonStr);

（4）、遍历对象中的属性和方法

for(key in Object) {

key:属性名和方法体

object[key]:属性值和方法体

}

使用  JSON.stringify(json);方法生成json的方法

41、Oracle分页,存储过程