java面试题3

hibernate 的原理？

1. 读取并解析Hibernate核心配置文件hibernate.cfg.xml

（数据库连接信息，方言，显示sql语句等）

2.读取并解析Hibernate映射文件，创建SessionFactory

3.打开Sesssion

4.创建事务Transation

5.持久化操作

6.提交事务

7.关闭Session

8.关闭SesstionFactory

至于我们为什么要用Hibernate，就从Hibernate的四个优点来说：全自动

首先、Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

其次、Hibernate是一个基于JDBC的主流持久化框架，很大程度的简化了DAO层编码工作。

再次、Hibernate使用Java的反射机制，而不是字节码增强程序类实现透明性。

最后、Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系。

15、session和cookie异同？如何让它们失效？Session.TimeOut = 30  半小时

1、session保存在服务器，客户端不知道其中的信息；cookie保存在客户端，服务器能够知道其中的信息。    

 2、session中保存的是对象，cookie中保存的是字符串。 

cookie 和session的区别是：cookie数据保存在客户端 硬盘，session数据保存在服务器端。

cookie 户端访问server端程序被调用被创建，而如果不设置过期时间，则表示这个cookie生命周期为浏览器会话期间，

只要关闭浏览器窗口，cookie就消失了。关闭浏览器只会使存储在客户端浏览器内存中的session cookie失效，不会使服务器端的session对象失效。

禁用cookie 在浏览器中将cookie移除

JAVA 中让session失效有哪些方法？

答：session.invalidate();

cookie 和session 的区别：

1、cookie数据存放在客户的浏览器上，session数据放在服务器上。

2、2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
   考虑到安全应当使用session。

3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能
   考虑到减轻服务器性能方面，应当使用COOKIE（相对session可以减轻服务器性能）。

4、单个cookie保存数据有限（不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。）

2.集合框架有哪些，可以说一下，它们的接口，实现类吗？

接口：

List特点：元素有顺序，元素可重复

Set特点：元素无放入顺序，元素不可重复

Map特点：元素按键值对存储，无放入顺序

 

List接口有三个实现类：LinkedList，ArrayList，Vector

 LinkedList，底层基于链状，增删快，查找慢；

 ArrayList，Vector;基于数组的，增删慢，查找快；

ArrayList，非线性安全的，效率高，Vector线性安全的，效率慢。

 

Set接口有：HashSet和 linkedHashSet

Map接口有三个实现类：HashMap，HashTable，LinkeHashMap

HashMap非线程安全，高效，支持null；

HashTable线程安全，低效，不支持null

List,set 是 Collection接口下的两个子接口

.jquery的选择器有哪些，说一下。属性有哪些？

基本选择器 l用法: $(‘#id’)返回值：根据 id属性匹配一个标签,封装成 jQuery对象 n

层次选择器用法:   $(”form input”)说明:在给定的祖先元素下匹配所有后代元素 n

 

  过滤选择器      3.1). :first用法: $(”tr:first”) ;  说明:匹配找到的第一个元素

attr(name [,value])  根据属性名获取属性值或者设置一个属性 

removeAttr(name)  根据属性名删除对应的属性

val([value])     获得匹配元素的当前值或者设置其值

4.大数据的处理？假如有一千万数据，你是怎么样处理的？

方an1：按主键分区   查询条件是主键  则分表变快  如果查询条件不是主键 则势必比未分表更慢 每个表分区union all关联就可以了

4.1 7. 怎么在海量数据中找出重复次数最多的一个？

方an1：先做hash，然后求模映射为小文件，求出每个小文件中重复次数最多的一个，并记录重复次数。然后找出上一步求出的数据中重复次数最多的一个就是所求（具体参kao前面的题）。

5.多线程。

5.1 sleep() 和 wait()有什么区别? ? ? ?

Sleep 是指休眠给定的时间，当这个时间达到之后，线程会再次醒来。

 Wait 是等待状态，多长时间不清楚，由另一个线程将其唤醒

5.2当一个线程进入一个对象的一个 synchronized方法后，其它线程是否可进入此对象的其它方法?

如只其它方法是同步方法，不可以进入。如果不是可以进入。

SpringMVC 原理

1.客户端请求被spring前端控制器DispatcherServlet捕获

2. 由DispatcherServlet控制器查询HandlerMapping，找到处理请求的Controller

3. DispatcherServlet将请求提交到Controller

4. Controller调用业务逻辑处理后，返回ModelAndView

5. DispatcherServlet查询对应的ViewResoler视图解析器，结合ModelAndView来渲染视图  

 6.将渲染的结果显示到客户

springmvc和struts2的对比

首先它们都web层的框架

spring mvc 开发效率比struts2 要高，springMVC请求只实列化一次 struts2没请求一次都会实列化一次

springMVC 是基于方法级别的一种拦截设计

struts2 是基于类的设计

Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存。

Hibernate一级缓存又称为“Session的缓存”。Session内置不能被卸载，Session的缓存是事务范围的缓存（Session对象的生命周期通常对应一个数据库事务或者一个应用事务）。一级缓存中，持久化类的每个实例都具有唯一的OID。

2.Hibernate二级缓存又称为“SessionFactory的缓存”。

由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，默认下SessionFactory不会启用这个插件。Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器。

12、ajax原理？优缺点？

Ajax的工作原理相当于在用户和服务器之间加了—个中间层(AJAX引擎),使用户操作与服务器响应异步化。并不是所有的用户请求都提交给服务器,像— 些数据验证和数据处理等都交给Ajax引擎自己来做, 只有确定需要从服务器读取新数据时再由Ajax引擎代为向服务器提交请求。

Ajax其核心有JavaScript、XMLHTTPRequest、DOM对象组成，通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用JavaScript来操作DOM而更新页面。这其中最关键的一步就是从服务器获得请求数据

14、Servlet的生命周期？如何实现的？

 

1.初始化阶段，调用init()方法。

2.响应客户端请求阶段，调用service()方法。

3.销毁阶段，调用desttory()方法。

常见的软件研发流程：瀑布模型，螺旋模型，RUP流程，IPD流程


瀑布模型核心思想是按工序将问题化简，
将功能的实现与设计分开，便于分工协作，
即采用结构化的分析与设计方法将逻辑实现与物理实现分开。


说下集合、map 。以及他们之间的区别和特点


ava中的集合包括三大类，
它们是Set、List和Map，
它们都处于java.util包中，Set、List和Map都是接口，
它们有各自的实现类。
Set的实现类主要有HashSet和TreeSet，
List的实现类主要有ArrayList，
Map的实现类主要有HashMap和TreeMap。


集合主要有Collection和Map接口。
List特点：元素有放入顺序，元素可重复 
Map特点：元素按键值对存储，无放入顺序 
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 
List接口有三个实现类：LinkedList，ArrayList，Vector 
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢 
ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低 
Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet 
SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现） 
Query接口有一个实现类：LinkList 
Map接口有三个实现类：HashMap，HashTable，LinkeHashMap 
HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null 
SortedMap有一个实现类：TreeMap 
其实最主要的是，list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对 
set 一般无序不重复.map kv 结构 list 有序 。




详细介绍： 
List特点：元素有放入顺序，元素可重复 
Map特点：元素按键值对存储，无放入顺序 
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 
List接口有三个实现类：LinkedList，ArrayList，Vector 
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢 
ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低 
Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet 
SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现） 
Query接口有一个实现类：LinkList 
Map接口有三个实现类：HashMap，HashTable，LinkeHashMap 
  HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null 
SortedMap有一个实现类：TreeMap 
其实最主要的是，list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对 
set 一般无序不重复.map kv 结构 list 有序 。






什么时候用StringBuffer ，当用字符串拼接时用什么，为什么。


1.String 字符串产量


2.StringBuffer 字符串变量（线程安全）


3.StringBuilder 字符串变量 （非线程安全）






1.String类型，是Java内的对象，是不可改变的对象，当每次对String进行改变时，都需要生成一个新的String对象，然后将指针指向一个新的对象，如果在一个循环里，不断的改变一个对象，就要不断的生成新的对象，如果对象多了，java的垃圾自动回收机制会开始工作了，所以效率很低，建议在不断更改String对象的地方不要使用String类型。


2.StringBuffer是个可变的对象，就是每次操作都是对对象本身进行操作，而不用生成新的对象，这样效率就会有很大的提高，在大部分情况下StringBuffer的效率要比String类型更高。


3.StringBuilder与StringBuffer一样是个可变的字符序列，提供与StringBuffer兼容的API，但是不能保证同步，


在用在字符串缓冲区被当作线程的情况使用，在单机非多线程的情况下使用StringBuilder会有比较好的效率，因为StringBuilder没有处理同步（Synchronized）问题。StringBuffer则会处理同步问题，StringBuild会在多线程下被操作，要改用Stringbuffer，让对象自行管理同步问题。






总结：StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问他，不存在不安全的因素了，则用StringBuilder。


如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用那么最好用StringBuffer


说下多线程的同步及优化


synchronized和Volatile
Volatile是轻量级的Synchronized，它在多处理器开发中保证了共享变量的“可见性”。


volatile 变量提供顺序和可见性保证


可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。


 线程：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。


 1、使用StringBuilder 避免递归 使用entrySet() 优化自定义hasCode()方法和equals()方法


内联式>嵌入式 > 外部式


如何配置缓存。
第三方常用组件 ehcache
<session-factory>
<property name="cache.use_second_level_cache">true</property>
</session-factory>
在需要使用二级缓存的配置文件处加配置
映射文件中：<cache usage="read-only"/>


Mysql 数据库优化
不要在生产环境程序中使用select * from 的形式查询数据。
只查询需要使用的列。
查询尽可能使用limit减少返回的行数，减少数据传输时间和带宽浪费


索引的不足之处上面都在说使用索引的好处，但过多的使用索引将会造成滥用。因此索引也会有它的缺点：


1.虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE和DELETE。因为更新表时，
MySQL不仅要保存数据，还要保存一下索引文件。


2.建立索引会占用磁盘空间的索引文件。
一般情况这个问题不太严重，
但如果你在一个大表上创建了多种组合索引，
索引文件的会膨胀很快。索引只是提高效率的一个因素，
如果你的MySQL有大数据量的表，
就需要花时间研究建立最优秀的索引，或优化查询语句。 


35 个 Java 代码性能优化总结
1、尽量指定类、方法的final修饰符
2、尽量重用对象
3、尽可能使用局部变量
4、及时关闭流
for (int i = 0; i < list.size(); i++) 
 
{...} 
 
建议替换为：
尽量减少对变量的重复计算 
 
for (int i = 0, int length = list.size(); i < length; i++) 
 
{...} 
6、尽量采用懒加载的策略，即在需要的时候才创建
if (i == 1) 
{ 
 
String str = "aaa"; 
 
list.add(str); 
 
} 
11、乘法和除法使用移位操作
例如：
for (val = 0; val < 100000; val += 5) 
 
{ 
 
a = val * 8; 
 
b = val / 2; 
 
} 
用移位操作可以极大地提高性能，因为在计算机底层，对位的操作是最方便、最快的，因此建议修改为：
for (val = 0; val < 100000; val += 5) 
 
{ 
 
a = val << 3; 
 
b = val >> 1; 
 
} 
12、循环内不要不断创建对象引用
例如：
for (int i = 1; i <= count; i++) 
 
{ 
 
Object obj = new Object(); 
 
} 
24、使用数据库连接池和线程池


顺序插入和随机访问比较多的场景使用ArrayList，元素删除和中间插入比较多的场景使用LinkedList
28、字符串变量和字符串常量equals的时候将字符串常量写在前面
这是一个比较常见的小技巧了，如果有以下代码：
String str = "123"; 
if (str.equals("123")) { 
 
... 
 
} 
建议修改为：
String str = "123"; 
if ("123".equals(str)) 
 
{ 
 
... 
 
} 
34、使用最有效率的方式去遍历Map
遍历Map的方式有很多，通常场景下我们需要的是遍历Map中的Key和Value，那么推荐使用的、效率最高的方式是：
public static void main(String[] args) 
 
{ 
 
HashMap<String, String> hm = new HashMap<String, String>(); 
 
hm.put("111", "222"); 
 
Set<Map.Entry<String, String>> entrySet = hm.entrySet(); 
 
Iterator<Map.Entry<String, String>> iter = entrySet.iterator(); while (iter.hasNext()) 
 
{ 
 
Map.Entry<String, String> entry = iter.next(); 
 
System.out.println(entry.getKey() + "\t" + entry.getValue()); 
 
} 
 
} 
public static void main(String[] args){
Map map=new HashMap();
map.put("key1", "value1");
map.put("key2", "value2");


for(Iterator it=map.keySet().iterator();it.hasNext();){
Object o=it.next();
System.out.println(o+""+map.get(o));
}

for(Iterator i=map.entrySet().iterator();i.hasNext();){
Entry e=(Entry) i.next();
System.out.println("键"+e.getKey () + "的值为" + e.getValue());
}
}


16、实体对象的三种状态以及转化关系？
Hibernate：瞬时态、持久态、游状态、移除态(最新Hibernate的四种状态)
瞬时态：当一个实体对象new后，对象就处于瞬时态，一个保存临时数据的内存区域，如果没有变量引用这个对象则被JVM
垃圾回收机制回收。这个对象保存的数据和数据库没有任何关系，通过Session的save() saveorUpdate()等方法把瞬时态
对象与数据库关联，并把数据更新到数据库中，这个对象才转换为持久态对象。
      
        持久态：对象的实例在数据库中有对应的记录，拥有一个持久化标识ID，对持久态对象进行删除后，数据库中对应的记录
也会删除，那持久态对象与数据库记录不存在对应关系，持久态对象变成移除态(瞬时态)
    游离态：当Session进行close() clear()等后，实体对象从持久态变成游离态，对象虽然拥有与数据库对应记录的标识，但是
因为对象已经从会话中清除，对象不在持久化管理内，所以处于游离态(托管态)
17、Hibernate常见的优化策略
制定合理的缓存策略(二级缓存、查询缓存)
               查询缓存：将HQL和SQL语句查询的结果作为键值对 进行缓存，默认关闭。
尽量使用延迟加载
开启hibernate.show_sql查看SQL语句，开发后关闭此选项
数据库本身优化，合理的索引


18、什么是WebService？
表面说是一个应用程序，调用这个应用程序不需要了解它的细节，跟调用者使用的编程语言没有关系，它是基于HTTP协议传
输数 据。
SOA概念：面向服务的架构思想，将应用程序的不同功能单元通过中立的锲约联系起来，独立于硬件平台、操作系统和编程
语言，使得各种形式的功能单元能够更好的集成。Web Service是SOA的一种较好解决方案。




写出常见的异常（一般面试写出5个就行）
ArithmeticException  ClassCastException NoSuchElementException NullPointerException SecurityException




分页思想
数据的结果集合 每页显示3条数据 当前页面是第2页
list<UserBean> list
每页显示的记录数 int pageSize=3  当前页面 int currentPage=2
求第二页的数据时从第几条开始到第几条结束？
   开始下标：startIndex = (currentPage-1)*pageSize
结束下标：endIndex=currentPage*pageSize
总记录数：totalCount=list.size()
list集合中的下标是从0开始 list.subList(startIndex,endIndex) 包括startIndex 而不包含endIndex
显示所有数据需要多少页？
int pageCount= (totalCount-1)/pageSize+1




function fun(){


//1.获取XMLHttpRequest对象
var xmlhttp = new XMLHttpRequest();
//2.向服务器发出请求
//第一个参数表示请求提交的方法
//第二个参数表示的是请求的地址
//第三个参数表示的是是否是异步处理  true表示异步   false 同步
xmlhttp.open("GET","Test08",true);
xmlhttp.send();
//3.监听请求服务的状态
xmlhttp.onreadystatechange = function(){
//4.判断请求的状态是否成功，响应的数据是否就绪
if(xmlhttp.readyState==4&&xmlhttp.status==200){
//5.获取服务器端发送过来的数据


var data = xmlhttp.responseText;
var d=eval("("+data+")");


for(var i=0;i<d.length;i++){
alert(d[i]);
}


}
};


}
事务处理
try{
conn.setAutoCommit(false);   //取消自动提交 
conn.commit();    //提交事务 
conn.setAutoCommit(true); 


}
 catch(SQLException e){ 
conn.rollback();    //出现异常，回滚事务 
con.setAutoCommit(true); 
e.printStackTrace(); 
throws new SystemException(e);   
} 


购物车实现
/****************1.获取数据*******************************/
//1.从客户端的表单中获取订单的相关的数据
//2.从购物车中获取订单的信息
ShopCar shopCar = ShopCar.getShopCarInstance(session);
double totalPrice = shopCar.getTotalPrice();
int quantity = shopCar.getTotalCount();
int alltype = shopCar.getTotalType();


//3.从购物车中获取订单详情的信息
List<McBean> mcList = shopCar.getList();
//4.从session获取下订单的用户信息
UserBean user = (UserBean) session.getAttribute("FRONT_USER");
/****************2.保存数据*******************************/
//保存订单的详情信息
//将订单中的每一个商品信息保存在订单中详细订单集合中
//****************3.将数据插入到数据库中*******************************/
//清空购物车


事务四大特性(简称ACID) 
1、原子性(Atomicity)：事务中的全部操作在数据库中是不可分割的，要么全部完成，要么均不执行。


2、一致性(Consistency)：几个并行执行的事务，其执行结果必须与按某一顺序串行执行的结果相一致。


3、隔离性(Isolation)：事务的执行不受其他事务的干扰，事务执行的中间结果对其他事务必须是透明的。


4、持久性(Durability)：对于任意已提交事务，系统必须保证该事务对数据库的改变不被丢失，即使数据库出现故障。     

->缓存管理


服务器从数据库查询出来的数据保存在
服务器内存或者硬盘中，下次使用相关数据
的时候就直接从内存或者硬盘中获取。


它介于应用程序和永久性数据存储源之间
缓存的物理介质通常是内存，而永久性数据存储源的
物理介质通常是硬盘或磁盘。


持久化的缓存的范围
1事务范围：hibernate的session 绑定
2进程范围：sessionfactory
3集群范围: 多个机器组成的服务器 缓存数据被多个机器共享 进程共享


一级缓存:
在session未被关闭之前
从数据库查询的数据会保存在内存中
再次查询会从缓存中获取


缓存的实现原理：
其实是一个类似于Map的对象，
key：主键，值：对象


使用二级缓存
ehcache的使用
导入相关架包
cache.uer_second_level_cache设为true
配置二级缓存的实现类

1: servlet中跳转的方式有哪几种？说下他们的区别（重定向 And 转发）


请求转发（服务器跳转）request.getRequestDispatcher("index.html").forward(request, response);
重定向 页面跳转 response.sendRedirect("success.html");


重定向
1.地址栏会发生改变，地址会变成跳转的页面的URL地址
2./  表示tomcat中webapps的根目录
3.可以跳转到外网地址和tomcat下其他应用的地址及当前应用下的所有的地址
4.不能数据共享
5.两次请求和两次响应


请求转发
1.地址栏不会发生变化，地址栏中的地址还是保留请求的地址
2./  表示的是项目的根目录
3.只能跳转到当前应用的所有地址
4.请求转发可以数据共享
5.一次请求和一次响应












-----------------------------------------------------------------------------
2：get提交和post提交的区别？
1.乱码处理方式不同
2.get提交携带数据时数据会显示在URL地址后面而post不会
3.设计出来的目的不同 
get被设计出来的目的是为了向服务器获取数据的
post目的就是为了向服务器上传数据的
4.get一般能够携带1024字节左右数据，而post可以携带2M以上
5.get能够携带数据的原因
获取数据时必须要让服务器知道客户端要获取哪些数据，所以才需要携带数据让服务器判断


-----------------------------------------------------------------------------
3：你项目权限是怎么设计的？（从涉及多少张表说起···）


不同的用户拥有不同的权限进行客户端访问
数据库中有三张表，用户表，角色表，菜单表
用户表和角色表通过中间表关联 角色表和菜单表通过中间表关联
通过用户ID就能找到对应的角色ID，根据角色ID又能找到对应的权限。
在数据存储层DAO层中写一个方法通过SQL语句获取用户权限的集合数据
然后在控制层判断用户是否登陆成功，登陆成功就调用业务层中相关的方法获取
权限集合然后保存在用户对象中
用户对象有临时属性，用来保存集合数据


自定义拦截器，用来判断用户请求的地址在不在该用户的权限集合中
如果在的话，拦截器就会放过，该用户就能根据对应的权限执行相关的操作。




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


4：你说下struts2和spring的区别是什么？
Struts2是类级别的拦截   SpringMVC是方法级别的拦截
拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式
SpringMVC的入口是servlet，而Struts2是filter
设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。


--------------------------------------------------------------------------------
struts2
1:Struts2的工作流程是什么？




工作流程：


1.客户端提交一个HttpServletRequest请求（action或JSP页面）。


2.请求被提交到一系列Filter过滤器，如ActionCleanUp和FilterDispatcher等。


3.FilterDispatcher是Struts2控制器的核心，它通常是过滤器链中的最后一个过滤器。


4.请求被发送到FilterDispatcher后，FilterDispatcher询问ActionMapper时候需要调用某个action来处理这个Request。


5.如果ActionMapper决定需要调用某个action，FilterDispatcher则把请求交给ActionProxy进行处理。


6.ActionProxy通过Configuration Manager询问框架的配置文件struts.xml，找到调用的action类。


7.ActionProxy创建一个ActionInvocation实例，通过代理模式调用Action。


8.action执行完毕后，返回一个result字符串，此时再按相反的顺序通过Intercepter拦截器。


9.最后ActionInvocation实例，负责根据struts.xml中配置result元素，找到与之相对应的result，决定进一步输出。






基本简要流程：
1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被FilterDispatcher接收。
3、根据struts.xml配置，找到需要调用的Action类和方法， 并通过IOC方式，将值注入给Aciton。
4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。
6、返回HTTP响应到客户端浏览器。






首先客户端发送请求，
struts核心控制器经过一系列的拦截器之后。
得到请求，然后根据配置文件得到相对应的类以及这个类拥有的方法，
根据请求调用对应的方法 ，最后把得到的结果返回给客户端


--------------------------------------------------------------------------------
2:Struts2是拦截器怎么配置实现？
1.创建一个java文件实现Interceptor接口
2.在struts.xml文件中注册刚刚创建的拦截器，然后引用自定义拦截器和默认拦截器




--------------------------------------------------------------------------------
3:实现一个Action有几种方式？
Action类似于servlet
1.简单的java对象 pojo
2.实现Action接口 5个常量：Success,none,error,input,login
execute方法：当没有指定要调用的方法的时候会执行
3.继承ActionSupport类 实现了Action接口 支持验证框架，国际化等功能












--------------------------------------------------------------------------------
hibernate
1:hibernate的工作流程？
1、通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件。
2、由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取解析映射信息。
3、通过config.buildSessionFactory();//得到sessionFactory。
4、sessionFactory.openSession();//得到session。
5、session.beginTransaction();//开启事务。
6、persistent operate;
7、session.getTransaction().commit();//提交事务
8、关闭session;
9、关闭sessionFactory;


1.加载配置文件，读取并解析映射信息
2.获取sessionFactory
3.获取session对象
4.具体的事务操作
5.关闭session




2:hibernate的缓存机制？


Hibernate是一个持久层框架，经常访问物理数据库，
为了降低应用程序对物理数据源访问的频次，
从而提高应用程序的运行性能。
缓存内的数据是对物理数据源中的数据的复制，
应用程序在运行时从缓存读写数据，
在特定的时刻或事件会同步缓存和物理数据源的数据
 Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存
 1.Hibernate一级缓存又称为“Session的缓存”
 2.Hibernate二级缓存又称为“SessionFactory的缓存”
 瞬时状态：此状态的对象存储于JVM内存中，与数据库的数据无关
 持久状态：此状态的对象由hibernate的框架管理，数据库存在与hibernate内存中，数据可由hibernate持久化（保存）到数据库中
 游离（脱管）状态：如果处于持久化的对象，其会话Session关闭后，此对象就会转变成游离（脱管）状态。



3:hibernate Get 和 Load 方法的区别？


作用根据主键查询数据
get 查询数据不存在返回null 没有采用延迟加载
load  查询数据不存在报错误 采用延迟加载【懒加载】 查询返回的是代理对象 如果查询的代理对象没有使用，不会进行真正的查询


4:Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)？




spring


1:spring的三大核心思想？
IOC控制反转 Di依赖注入 AOP面向切面编程



2：续上-
什么是aop？ aop具体有哪些应用？spring aop的实现？
面向切面编程
通过预编译方式和运行期动态代理实现在不修改源代码的情况
下给程序动态统一添加功能的一种技术


可以用在日志，加权限，事物，异常管理等方面。

struts工作流程:
客户端发送请求经过过滤器到核心控制器，控制器根据配置文件找到对应类，然后根据反射机制实例化类,调用其相对应的方法，调用方法前经过一系列拦截器，方法执行完结束拦截器，
根据返回的字符串响应客户端


springMVC的工作流程：
客户端发送请求，到达前端控制器，再由处理器映射器根据请求地址找到相关的类
接着处理器适配器判断该类是否符合规范，如果是则执行其方法并且返回一个视图
最后由视图解析器将其解析成jsp页面返回给前端控制器并相应客户端






spring mvc与struts2的区别:
Struts2是类级别的拦截， 一个类对应一个request上下文，SpringMVC是方法级别的拦截
SpringMVC开发效率和性能高于Struts2
SpringMVC是单例模式，struts2是多例模式






Hibernate:(属于数据访问层)
hibernate是ORM框架 ORM框架是对对表的操作转换为对对象的操作
hibernate提供了强大的对象和关系数据库映射以及查询功能
1.         读取并解析配置文件
2.         读取并解析映射信息，创建SessionFactory
3.         打开Sesssion
4.         创建事务Transation
5.         持久化操作
6.         提交事务
7.         关闭Session
8.         关闭SesstionFactory


hibernate的缓存管理的机制：
机制：  先到一级缓存中查询记录，如果有，就直接从缓存中取，如果没有，到2级缓存中取 ，还是没有 就到数据库中查询记录，
          并把这条记录根据主键ID放到一级，二级缓存（类似于Map：key:ID,value:对象） 


 Hibernate的一级缓存：Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate管理的，一般情况下无需进行干预；
 Hibernate的二级缓存：依靠第三方组件：echache，为SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。
 查询缓存：是在二级缓存的基础上




mybatis的工作流程：
先写conf.xml配置文件，加载并初始化。
构建sqlsessionfactory，打开sqlsessionfactory.open（），创建一个sqlsession，
映射SQL的标识字符串Sring satatemenet
执行查询返回一个唯一user对象的SQL，session.select(statemenet,参数)


(1)加载配置并初始化
触发条件：加载配置文件
配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），
存储在内存中。


(2)接收调用请求
触发条件：调用Mybatis提供的API
传入参数：为SQL的ID和传入参数对象
处理过程：将请求传递给下层的请求处理层进行处理。


(3)处理操作请求 触发条件：API接口层传递请求过来


传入参数：为SQL的ID和传入参数对象
处理过程：
(A)根据SQL的ID查找对应的MappedStatement对象。
(B)根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。
(C)获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。
(D)根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。
(E)释放连接资源。


(4)返回处理结果将最终的处理结果返回。




mybatis与hibernate的区别:
mybatis是把sql语句与java代码分离了，sql语句在xml文件配置里面
hibernate封装地比较彻底，简化了dao层的编码工作，但是不够灵活
hibernate数据库移植性远大于mybatis。
hibernate拥有完整的日志系统，mybatis则欠缺一些。
sql直接优化上，mybatis要比hibernate方便很多




spring三大核心思想:
IOC(控制反转):控制权由对象本身转向容器，把new过程交给spring容器去处理，不需要自己去创建它


DI(依赖注入):属性注入，构造注入，接口注入
创建被调用者实例的工作由Spring容器来完成，然后注入给调用者，因此被称为依赖注入


AOP(面向切面):AOP是面向对象编程的有力补充，可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术


Spring中的七大模块:
SpringDAO、SpringORM、SpringAOP、Spring Web、Spring Web MVC、Spring core、Srping context






String与StringBuillder、StringBuffer的区别:
String是字符串常量
StringBuillder、StringBuffer是字符串变量
StringBuillder的线程非安全，但是效率高
StringBuffer线程安全，效率没StringBuillder高






JDBC
注册和加载数据库驱动程序
建立与数据库的连接通道
构造sql语句
执行sql语句
关闭资源






抽象：忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方向。


继承：对象的一个新类可以从现有的类中派生，这个过程称为类继承。


封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。


多态性：多态性是指允许不同类的对象对同一消息作出响应。




Object:
Object类的方法是所有类都有的，因为所有类都是继承Object。
Object的方法有 int hashCode（），String toString（），void notify（），void notifyAll（），void wait（），getClass()，clone()






public/private/protected的具体区别:
public：public表明该数据成员、成员函数是对所有用户开放，所有用户都可以直接调用
private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用
protected：protected同包类以及子类可以使用，外部class不能调用




java多线程有几种方式实现：
1、继承Tread类，重写run函数
2、实现Runnable，重写run函数
3、实现Callable接口，重写call函数




UML是什么，有哪些图:
UML是统一建模语言，是用来对软件密集系统进行可视化建模的一种语言。
有：用例图、类图、对象图、活动图、状态图、序列图、协作图、构件图、部署图




软件的生命周期分哪几个阶段，各个阶段都需要出那些文档：
1、问题定义
2、可行性研究
3、需求分析
4、开发阶段
5、维护




反射：
简单通俗一点，就是在运行期间，如果我们要产生某个类的对象，Java虚拟机（JVM）会检查该类型的Class对象是否已被加载。如果没有被加载，
JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象。
反射的方法有：Object.getclass()，class.forName（），类名.class（）




Servlet的生命周期：
servlet被服务器实例化后，容器运行其init（）方法，请求到达时运行其service方法，service方法自动派遣
运行与请求对应的dogGet或doPost方法，当服务器决定将实例销毁的时候调用其destroy方法。






ArrayList,Vector,LinkedList的区别：
ArrayList和Vector都是使用数组方式存储数据，Vector使用synchronize方法，线程安全，
性能比ArrayList差，查找快，增删慢。
LinkList使用的是双向链表实现存储，增删快，查找慢。






&和&&的区别：
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。






HashMap和Hashtable的区别：
HashMap允许空键值，非线程安全，效率快
Hashtable不允许空键值，线程安全，效率慢。






final,finally,finalize区别。
final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法。




sleep（）和wait（）有什么区别：
sleep是线程类的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是
监控状态依然保持，到时后会自动恢复。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，
只有针对此对象发出notify方法后本线程才进入对象锁定池准备获得对象锁进入运行状态。


Sleep 是指休眠给定的时间，当这个时间达到之后，线程会再次醒来。
Wait 是等待状态，多长时间不清楚，由另一个线程将其唤醒。




同步和异步的区别：
同步:发送一个请求,等待返回,然后再发送下一个请求 
异步:发送一个请求,不等待返回,随时可以再发送下一个请求 


游标：
提供了一种从表中检索数据并进行操作的灵活手段,主要用在服务器上，处理由客户端发送给服务器端的SQL语句。是一种能从包括多条数据记录的结果集中每次提取一条记录的机制。
游标充当指针的作用。一次只能指向一行。是一种临时的数据库对象。游标提供了逐行的基础上操作表中数据的方法。


游标组成部分：
1、声明游标。
2、打开游标。
3、从游标中查找信息。
4、关闭游标。
5、释放游标。


存储过程和函数的区别：
1、标识符不同。函数的标识符为function，过程为：procedure。
2、函数中有返回值，且必须返回，而过程没有返回值。
3、过程无返回值类型，不能将结果直接赋值给变量；函数有返回值类型，调用时，除在select中，必须将返回值赋给变量。
4、函数可以在select语句中直接使用，而过程不能。




JS：
JavaScript也是一门面向对象的编程语言，一种广泛用于客户端Web开发的脚本语言，常用来给HTML页面添加动态功能，可以动态的添加属性和方法。


jquery:
jQuery是个轻量级脚本库，拥有强大的选择器，出色的DOM操作的封装，完整的文档,出色的浏览器兼容性，丰富的插件支持
能使用户的HTML页保持代码和HTML内容分离


ajax原理？优缺点？
Ajax的工作原理相当于在用户和服务器之间加了―个中间层(AJAX引擎),使用户操作与服务器响应异步化。并不是所有的用户请求都提交给服务器,
像―些数据验证和数据处理等都交给Ajax引擎自己来做, 只有确定需要从服务器读取新数据时再由Ajax引擎代为向服务器提交请求。




Ajax其核心有JavaScript、XMLHTTPRequest、DOM对象组成，通过XmlHttpRequest对象来向服务器发异步请求，从服务器获得数据，然后用JavaScript来操作DOM而更新页面。
这其中最关键的一步就是从服务器获得请求数据




Json：
json是一种轻量级的数据交换格式,易于机器的解析和生成,能够通过javaScript中的eval（）函数解析Json，使人们读写根据容易






你知道有哪几种表单提交方式:
get  post一个用于获取数据，一个用于修改数据
1.Post传输数据时，不需要在URL中显示出来，而Get方法要在URL中显示
2.Post传输的数据量大而Get方法由于受到URL长度的限制




session和cookie异同？如何让它们失效？
Session.TimeOut = 30  半小时
1、session保存在服务器，客户端不知道其中的信息；cookie保存在客户端，服务器能够知道其中的信息。




java常用包：
java.applet
java.awt
java.io
java.util
java.lang
java.net
java.sql


常用类：
String
Integer
Long
File
Date
Thread




常见异常：
NullPointerException - 空指针引用异常
RuntimeException-运行时异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常


error和exception有什么区别?
Error(错误)表示系统级的错误和程序不必处理的异常，比如内存不足，除了退出运行外别无选择
Eexception(违例)表示需要捕捉或者需要程序进行处理的异常,它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。




JSP中九大内置对象为： 
request            请求对象　                类型 javax.servlet.ServletRequest        作用域 Request
response          响应对象                   类型 javax.servlet.SrvletResponse       作用域  Page
pageContext    页面上下文对象       类型 javax.servlet.jsp.PageContext      作用域    Page
session            会话对象                   类型 javax.servlet.http.HttpSession       作用域    Session
application       应用程序对象          类型 javax.servlet.ServletContext          作用域    Application
out                   输出对象                   类型 javax.servlet.jsp.JspWriter             作用域    Page
config              配置对象                  类型 javax.servlet.ServletConfig            作用域    Page
page               页面对象                  类型 javax.lang.Object                            作用域    Page
exception        例外对象                 类型 javax.lang.Throwable                     作用域    page




在一个JSP页面包含另一个JSP页面的三种方式：
1、include指令
2、include标准动作
3、采用JSTL




事务:
事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。
事务有4个属性：原子性、一致性、隔离性、持续性。






单例模式：
1、饿汉式
饿汉式，这种方式基于classloder机制避免了多线程的同步问题
不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法
但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到lazy loading的效果。

public class Singleton {
private static Singleton instance=new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return instance;
}
}




3、懒汉式  
懒汉式,线程不安全  
public class Singleton2 {     
private static Singleton2 instance;      
private Singleton2(){} 




    public static Singleton2 getInstance(){  
if(instance==null){    
instance=new Singleton2();   
}    
return instance;   
}   
} 






排序方法：
冒泡排序算法:
1 import java.util.Arrays; 
2 public class Test2{   
3         public static void main(String[] args){  
4                 int[] a={5,4,2,4,9,1};  
5                 Arrays.sort(a);  //进行排序
6                 for(int i: a){
7                         System.out.print(i);
8                 }  
9         } 
10 }






冒泡排序算法:
1  public static int[] bubbleSort(int[] args){//冒泡排序算法  
2                 for(int i=0;i<args.length-1;i++){   
3                         for(int j=i+1;j<args.length;j++){  
4                                 if (args[i]>args[j]){   
5                                         int temp=args[i];  
6                                         args[i]=args[j];  
7                                         args[j]=temp;  
8                                 }  
9                         } 
10                 }  
11                 return args; 
12         }






选择排序算法:
1 public static int[] selectSort(int[] args){//选择排序算法  
2                 for (int i=0;i<args.length-1 i++ ){
3                         int min=i;
4                         for (int j=i+1;j<args.length j++ ){
5                                 if (args[min]>args[j]){
6                                         min=j;
7                                 }
8                         }
9                         if (min!=i){
10                         int temp=args[i];
11                         args[i]=args[min];
12                         args[min]=temp;
13                         }
14                 }
15                 return args;
16         }