今天在这里为大家分享两个部分的面试题，分别为数据库部分，以及流行框架部分，这也是在以往的面试过程中不管是在笔试还是在面试的过程中都少不了的两个模块。
首先来看数据库部分的java面试题，不止是在面试过程中，在日常的编程过程中有关于数据库的知识也是非常频繁的，因此不过是因为面试找到一份好的工作也好，还是在以后的日常工作总能够用到也好，在这一个环节还是希望大家能够可以认真的去看去理解。总是会起到的作用的。
五. 数据库部分
1、用两种方式根据部门号从高到低，工资从低到高列出每个员工的信息。
employee:
eid,ename,salary,deptid;
select * from employee order by deptid desc,salary
2、列出各个部门中工资高于本部门的平均工资的员工数和部门号，并按部门号排序
创建表：
mysql> create table employee921(id int primary key auto_increment,name varchar(5
0),salary bigint,deptid int);
插入实验数据：
mysql> insert into employee921 values(null,'zs',1000,1),(null,'ls',1100,1),(null
,'ww',1100,1),(null,'zl',900,1) ,(null,'zl',1000,2), (null,'zl',900,2) ,(null,'z
l',1000,2) , (null,'zl',1100,2);
编写sql 语句：
()select avg(salary) from employee921 group by deptid;
()mysql> select employee921.id,employee921.name,employee921.salary,employee921.dep
tid tid from employee921 where salary > (select avg(salary) from employee921 where deptid =
tid);
效率低的一个语句，仅供学习参考使用(在group by 之后不能使用where，只能使用having，
在group by 之前可以使用where，即表示对过滤后的结果分组)：
mysql> select employee921.id,employee921.name,employee921.salary,employee921.dep
tid tid from employee921 where salary > (select avg(salary) from employee921 group by deptid
having deptid = tid);
()select count(*) ,tid
from (
select employee921.id,employee921.name,employee921.salary,employee921.deptid tid
from employee921
where salary >
(select avg(salary) from employee921 where deptid = tid)
) as t
group by tid ;
另外一种方式：关联查询
select a.ename,a.salary,a.deptid
from emp a,
(select deptd,avg(salary) avgsal from emp group by deptid ) b
where a.deptid=b.deptid and a.salary>b.avgsal;
3、存储过程与触发器必须讲，经常被面试到?
create procedure insert_Student (_name varchar(50),_age int ,out _id int)
begin
insert into student value(null,_name,_age);
select max(stuId) into _id from student;
end;
call insert_Student('wfz',23,@id);
select @id;
mysql> create trigger update_Student BEFORE update on student FOR EACH ROW
-> select * from student;
触发器不允许返回结果
create trigger update_Student BEFORE update on student FOR EACH ROW
insert into student value(null,'zxx',28);
mysql 的触发器目前不能对当前表进行操作
create trigger update_Student BEFORE update on student FOR EACH ROW
delete from articles where id=8;
这个例子不是很好，好是用删除一个用户时，顺带删除该用户的所有帖子
这里要注意使用OLD.id
触发器用处还是很多的，比如校内网、开心网、Facebook，你发一个日志，自动通知好友，其
实就是在增加日志时做一个后触发，再向通知表中写入条目。因为触发器效率高。而UCH 没有
用触发器，效率和数据处理能力都很低。
存储过程的实验步骤：
mysql> delimiter |
mysql> create procedure insertArticle_Procedure (pTitle varchar(50),pBid int,out
pId int)
-> begin
-> insert into article1 value(null,pTitle,pBid);
-> select max(id) into pId from article1;
-> end;
-> |
Query OK, 0 rows affected (0.05 sec)
mysql> call insertArticle_Procedure('传智播客',1,@pid);
-> |
Query OK, 0 rows affected (0.00 sec)
mysql> delimiter ;
mysql> select @pid;
+------+
| @pid |
+------+
| 3 |
+------+
1 row in set (0.00 sec)
mysql> select * from article1;
+----+--------------+------+
| id | title | bid |
+----+--------------+------+
| 1 | test | 1 |
| 2 | chuanzhiboke | 1 |
| 3 | 传智播客| 1 |
+----+--------------+------+
3 rows in set (0.00 sec)
触发器的实验步骤：
create table board1(id int primary key auto_increment,name varchar(50),ar
ticleCount int);
create table article1(id int primary key auto_increment,title varchar(50)
,bid int references board1(id));
delimiter |
create trigger insertArticle_Trigger after insert on article1 for each ro
w begin
-> update board1 set articleCount=articleCount+1 where id= NEW.bid;
-> end;
-> |
delimiter ;
insert into board1 value (null,'test',0);
insert into article1 value(null,'test',1);
还有，每插入一个帖子，都希望将版面表中的后发帖时间，帖子总数字段进行同步更新，用
触发器做效率就很高。下次课设计这样一个案例，写触发器时，对于后发帖时间可能需要用
declare 方式声明一个变量，或者是用NEW.posttime 来生成。
4、数据库三范式是什么?
第一范式(1NF)：字段具有原子性,不可再分。所有关系型数据库系统都满足第一范式)
数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为
一个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的
字段。
第二范式(2NF)：
第二范式(2NF)是在第一范式(1NF)的基础上建立起来的，即满足第二范式(2NF)必须先
满足第一范式(1NF)。
要求数据库表中的每个实例或行必须可以被惟一地区分。通常需要为表加上一个列，以存储各
个实例的惟一标识。这个惟一属性列被称为主关键字或主键。
第二范式(2NF)要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主
关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个
新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存
储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。
第三范式的要求如下：
满足第三范式(3NF)必须先满足第二范式(2NF)。简而言之，第三范式(3NF)要求一个数
据库表中不包含已在其它表中已包含的非主关键字信息。
所以第三范式具有如下特征：
1，每一列只有一个值
2，每一行都能区分。
3，每一个表都不包含其他表已经包含的非主关键字信息。
例如，帖子表中只能出现发帖人的id ，而不能出现发帖人的id ，还同时出现发帖人姓名，否则，
只要出现同一发帖人id 的所有记录，它们中的姓名部分都必须严格保持一致，这就是数据冗余。
5、说出一些数据库优化方面的经验?
用PreparedStatement 一般来说比Statement 性能高：一个sql 发给服务器去执行，涉及步骤：
语法检查、语义分析， 编译，缓存
“inert into user values(1,1,1)”-?二进制
“inert into user values(2,2,2)”-?二进制
“inert into user values(?,?,?)”-?二进制
有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就去
掉外键。(比喻：就好比免检产品，就是为了提高效率，充分相信产品的制造商)
(对于hibernate 来说，就应该有一个变化： empleyee->Deptment 对象，现在设计时就成了
employee?deptid)
看mysql 帮助文档子查询章节的后部分，例如，根据扫描的原理，下面的子查询语句要比第
二条关联查询的效率高：
1. select e.name,e.salary where e.managerid=(select id from employee where name='zxx');
2. select e.name,e.salary,m.name,m.salary from employees e,employees m where
e.managerid = m.id and m.name='zxx';
表中允许适当冗余，譬如，主题帖的回复数量和后回复时间等
将姓名和密码单独从用户表中独立出来。这可以是非常好的一对一的案例哟!
sql 语句全部大写，特别是列名和表名都大写。特别是sql 命令的缓存功能，更加需要统一大小
写，sql 语句?发给oracle 服务器?语法检查和编译成为内部指令?缓存和执行指令。根据缓存的
特点，不要拼凑条件，而是用?和PreparedStatment
还有索引对查询性能的改进也是值得关注的。
备注：下面是关于性能的讨论举例
4 航班3 个城市
m*n
select * from flight,city where flight.startcityid=city.cityid and city.name='beijing';
m + n
select * from flight where startcityid = (select cityid from city where cityname='beijing');
select flight.id,'beijing',flight.flightTime from flight where startcityid = (select cityid from city where
cityname='beijing')
6、union 和union all 有什么不同?
假设我们有一个表Student，包括以下字段与数据：
drop table student;
create table student
( id int primary key,
name nvarchar2(50) not null,
score number not null
);
insert into student values(1,'Aaron',78);
insert into student values(2,'Bill',76);
insert into student values(3,'Cindy',89);
insert into student values(4,'Damon',90);
insert into student values(5,'Ella',73);
insert into student values(6,'Frado',61);
insert into student values(7,'Gill',99);
insert into student values(8,'Hellen',56);
insert into student values(9,'Ivan',93);
insert into student values(10,'Jay',90);
commit;
Union 和Union All 的区别。
select *
from student
where id < 4
union
select *
from student
where id > 2 and id < 6
结果将是
1 Aaron 78
2 Bill 76
3 Cindy 89
4 Damon 90
5 Ella 73
如果换成Union All 连接两个结果集，则返回结果是：
1 Aaron 78
2 Bill 76
3 Cindy 89
3 Cindy 89
4 Damon 90
5 Ella 73
可以看到，Union 和Union All 的区别之一在于对重复结果的处理。
UNION 在进行表链接后会筛选掉重复的记录，所以在表链接后会对所产生的结果集进行排
序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，常见的是
过程表与历史表UNION。如：
select * from gc_dfys
union
select * from ls_jg_dfys
这个SQL 在运行时先取出两个表的结果，再用排序空间进行排序删除重复的记录，后返
回结果集，如果表数据量大的话可能会导致用磁盘进行排序。
而UNION ALL 只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有重
复的数据，那么返回的结果集就会包含重复的数据了。
从效率上说，UNION ALL 要比UNION 快很多，所以，如果可以确认合并的两个结果集中不
包含重复的数据的话，那么就使用UNION ALL，
7.分页语句
取出sql 表中第31 到40 的记录(以自动增长ID 为主键)
sql server 方案1：
select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id
sql server 方案2：
select top 10 * from t where id in (select top 40 id from t order by id) order by id desc
mysql 方案：select * from t order by id limit 30,10
oracle 方案：select * from (select rownum r,* from t where r<=40) where r>30
--------------------待整理进去的内容-------------------------------------
pageSize=20;
pageNo = 5;
1.分页技术1(直接利用sql 语句进行分页，效率高和推荐的)
mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;
oracle: sql = "select * from " +
"(select rownum r,* from " +
"(select * from articles order by postime desc)" +
"where rownum<= " + pageNo*pageSize +") tmp " +
"where r>" + (pageNo-1)*pageSize;
注释：第7 行保证rownum 的顺序是确定的，因为oracle 的索引会造成rownum 返回不同的值
简洋提示：没有order by 时，rownum 按顺序输出，一旦有了order by，rownum 不按顺序输出了，
这说明rownum 是排序前的编号。如果对order by 从句中的字段建立了索引，那么，rownum 也
是按顺序输出的，因为这时候生成原始的查询结果集时会参照索引表的顺序来构建。
sqlserver:sql = "select top 10 * from id not id(select top " + (pageNo-1)*pageSize + "id from articles)"
DataSource ds = new InitialContext().lookup(jndiurl);
Connection cn = ds.getConnection();
//"select * from user where id=?" --->binary directive
PreparedStatement pstmt = cn.prepareSatement(sql);
ResultSet rs = pstmt.executeQuery()
while(rs.next())
{
out.println(rs.getString(1));
}
2.不可滚动的游标
pageSize=20;
pageNo = 5;
cn = null
stmt = null;
rs = null;
try
{s
qlserver:sql = "select * from articles";
DataSource ds = new InitialContext().lookup(jndiurl);
Connection cn = ds.getConnection();
//"select * from user where id=?" --->binary directive
PreparedStatement pstmt = cn.prepareSatement(sql);
ResultSet rs = pstmt.executeQuery()
for(int j=0;j<(pageNo-1)*pageSize;j++)
{
rs.next();
}
int i=0;
while(rs.next() && i<10)
{
i++;
out.println(rs.getString(1));
}}c
acth(){}
finnaly
{
if(rs!=null)try{rs.close();}catch(Exception e){}
if(stm.........
if(cn............
}
3.可滚动的游标
pageSize=20;
pageNo = 5;
cn = null
stmt = null;
rs = null;
try
{s
qlserver:sql = "select * from articles";
DataSource ds = new InitialContext().lookup(jndiurl);
Connection cn = ds.getConnection();
//"select * from user where id=?" --->binary directive
PreparedStatement pstmt = cn.prepareSatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,...);
//根据上面这行代码的异常SQLFeatureNotSupportedException，就可判断驱动是否支持可滚动游
标
ResultSet rs = pstmt.executeQuery()
rs.absolute((pageNo-1)*pageSize)
int i=0;
while(rs.next() && i<10)
{
i++;
out.println(rs.getString(1));
}}c
acth(){}
finnaly
{
if(rs!=null)try{rs.close();}catch(Exception e){}
if(stm.........
if(cn............
}
8.用一条SQL 语句查询出每门课都大于80 分的学生姓名
name kecheng fenshu
张三语文81
张三数学75
李四语文76
李四数学90
王五语文81
王五数学100
王五英语90
准备数据的sql 代码：
create table score(id int primary key auto_increment,name varchar(20),subject varchar(20),score int);
insert into score values
(null,'张三','语文',81),
(null,'张三','数学',75),
(null,'李四','语文',76),
(null,'李四','数学',90),
(null,'王五','语文',81),
(null,'王五','数学',100),
(null,'王五','英语',90);
提示：当百思不得其解时，请理想思维，把小变成大做，把大变成小做，
答案：
A: select distinct name from score where name not in (select distinct name from score where
score<=80)
B:select distince name t1 from score where 80< all (select score from score where name=t1);
9.所有部门之间的比赛组合
一个叫department 的表，里面只有一个字段name,一共有4 条纪录，分别是a,b,c,d,对应四个球
对，现在四个球对进行比赛，用一条sql 语句显示所有可能的比赛组合.
答：select a.name, b.name
from team a, team b
where a.name < b.name
10.每个月份的发生额都比101 科目多的科目
请用SQL 语句实现：从TestDB 数据表中查询出所有月份的发生额都比101 科目相应月份的发
生额高的科目。请注意：TestDB 中有很多科目，都有1-12 月份的发生额。
AccID：科目代码，Occmonth：发生额月份，DebitOccur：发生额。
数据库名：JcyAudit，数据集：Select * from TestDB
准备数据的sql 代码：
drop table if exists TestDB;
create table TestDB(id int primary key auto_increment,AccID varchar(20), Occmonth date,
DebitOccur bigint);
insert into TestDB values
(null,'101','1988-1-1',100),
(null,'101','1988-2-1',110),
(null,'101','1988-3-1',120),
(null,'101','1988-4-1',100),
(null,'101','1988-5-1',100),
(null,'101','1988-6-1',100),
(null,'101','1988-7-1',100),
(null,'101','1988-8-1',100);
--复制上面的数据，故意把第一个月份的发生额数字改小一点
insert into TestDB values
(null,'102','1988-1-1',90),
(null,'102','1988-2-1',110),
(null,'102','1988-3-1',120),
(null,'102','1988-4-1',100),
(null,'102','1988-5-1',100),
(null,'102','1988-6-1',100),
(null,'102','1988-7-1',100),
(null,'102','1988-8-1',100);
--复制上面的数据，故意把所有发生额数字改大一点
insert into TestDB values
(null,'103','1988-1-1',150),
(null,'103','1988-2-1',160),
(null,'103','1988-3-1',180),
(null,'103','1988-4-1',120),
(null,'103','1988-5-1',120),
(null,'103','1988-6-1',120),
(null,'103','1988-7-1',120),
(null,'103','1988-8-1',120);
--复制上面的数据，故意把所有发生额数字改大一点
insert into TestDB values
(null,'104','1988-1-1',130),
(null,'104','1988-2-1',130),
(null,'104','1988-3-1',140),
(null,'104','1988-4-1',150),
(null,'104','1988-5-1',160),
(null,'104','1988-6-1',170),
(null,'104','1988-7-1',180),
(null,'104','1988-8-1',140);
--复制上面的数据，故意把第二个月份的发生额数字改小一点
insert into TestDB values
(null,'105','1988-1-1',100),
(null,'105','1988-2-1',80),
(null,'105','1988-3-1',120),
(null,'105','1988-4-1',100),
(null,'105','1988-5-1',100),
(null,'105','1988-6-1',100),
(null,'105','1988-7-1',100),
(null,'105','1988-8-1',100);
答案：
select distinct AccID from TestDB
where AccID not in
(select TestDB.AccIDfrom TestDB,
(select * from TestDB where AccID='101') as db101
where TestDB.Occmonth=db101.Occmonth and TestDB.DebitOccur<=db101.DebitOccur
);
11.统计每年每月的信息
year month amount
1991 1 1.1
1991 2 1.2
1991 3 1.3
1991 4 1.4
1992 1 2.1
1992 2 2.2
1992 3 2.3
1992 4 2.4
查成这样一个结果
year m1 m2 m3 m4
1991 1.1 1.2 1.3 1.4
1992 2.1 2.2 2.3 2.4
提示：这个与工资条非常类似，与学生的科目成绩也很相似。
准备sql 语句：
drop table if exists sales;
create table sales(id int auto_increment primary key,year varchar(10), month varchar(10), amount
float(2,1));
insert into sales values
(null,'1991','1',1.1),
(null,'1991','2',1.2),
(null,'1991','3',1.3),
(null,'1991','4',1.4),
(null,'1992','1',2.1),
(null,'1992','2',2.2),
(null,'1992','3',2.3),
(null,'1992','4',2.4);
答案一、
select sales.year ,
(select t.amount from sales t where t.month='1' and t.year= sales.year) '1',
(select t.amount from sales t where t.month='1' and t.year= sales.year) '2',
(select t.amount from sales t where t.month='1' and t.year= sales.year) '3',
(select t.amount from sales t where t.month='1' and t.year= sales.year) as '4'
from sales group by year;
12.显示文章标题，发帖人、后回复时间
表：id,title,postuser,postdate,parentid
准备sql 语句：
drop table if exists articles;
create table articles(id int auto_increment primary key,title varchar(50), postuser varchar(10), postdate
datetime,parentid int references articles(id));
insert into articles values
(null,'第一条','张三','1998-10-10 12:32:32',null),
(null,'第二条','张三','1998-10-10 12:34:32',null),
(null,'第一条回复1','李四','1998-10-10 12:35:32',1),
(null,'第二条回复1','李四','1998-10-10 12:36:32',2),
(null,'第一条回复2','王五','1998-10-10 12:37:32',1),
(null,'第一条回复3','李四','1998-10-10 12:38:32',1),
(null,'第二条回复2','李四','1998-10-10 12:39:32',2),
(null,'第一条回复4','王五','1998-10-10 12:39:40',1);
答案：
select a.title,a.postuser,
(select max(postdate) from articles where parentid=a.id) reply
from articles a where a.parentid is null;
注释：子查询可以用在选择列中，也可用于where 的比较条件中，还可以用于from 从句中。
13.删除除了id 号不同,其他都相同的学生冗余信息
2.学生表如下:
id 号学号姓名课程编号课程名称分数
1 2005001 张三0001 数学69
2 2005002 李四0001 数学89
3 2005001 张三0001 数学69
A: delete from tablename where id 号not in(select min(id 号) from tablename group by 学号,姓名,
课程编号,课程名称,分数)
实验：
create table student2(id int auto_increment primary key,code varchar(20),name varchar(20));
insert into student2 values(null,'2005001','张三'),(null,'2005002','李四'),(null,'2005001','张三');
//如下语句，mysql 报告错误，可能删除依赖后面统计语句，而删除又导致统计语句结果不一致。
delete from student2 where id not in(select min(id) from student2 group by name);
//但是，如下语句没有问题：
select * from student2 where id not in(select min(id) from student2 group by name);
//于是，我想先把分组的结果做成虚表，然后从虚表中选出结果，后再将结果作为删除的条件
数据。
delete from student2 where id not in(select mid from (select min(id) mid
from student2 group by name) as t);
或者：
delete from student2 where id not in(select min(id) from (select * from s
tudent2) as t group by t.name);
14.航空网的几个航班查询题：
表结构如下：
flight{flightID,StartCityID ,endCityID,StartTime}
city{cityID, CityName)
实验环境：
create table city(cityID int auto_increment primary key,cityName varchar(20));
create table flight (flightID int auto_increment primary key,
StartCityID int references city(cityID),
endCityID int references city(cityID),
StartTime timestamp);
//航班本来应该没有日期部分才好，但是下面的题目当中涉及到了日期
insert into city values(null,'北京'),(null,'上海'),(null,'广州');
insert into flight values
(null,1,2,'9:37:23'),(null,1,3,'9:37:23'),(null,1,2,'10:37:23'),(null,2,3,'10:37:23');
1、查询起飞城市是北京的所有航班，按到达城市的名字排序
参与运算的列是我起码能够显示出来的那些列，但终我不一定把它们显示出来。各个表组合
出来的中间结果字段中必须包含所有运算的字段。
select * from flight f,city c
where f.endcityid = c.cityid and startcityid =
(select c1.cityid from city c1 where c1.cityname = "北京")
order by c.cityname asc;
mysql> select flight.flightid,'北京' startcity, e.cityname from flight,city e wh
ere flight.endcityid=e.cityid and flight.startcityid=(select cityid from city wh
ere cityname='北京');
mysql> select flight.flightid,s.cityname,e.cityname from flight,city s,city e wh
ere flight.startcityid=s.cityid and s.cityname='北京' and flight.endCityId=e.cit
yID order by e.cityName desc;
2、查询北京到上海的所有航班纪录(起飞城市，到达城市，起飞时间，航班号)
select c1.CityName,c2.CityName,f.StartTime,f.flightID
from city c1,city c2,flight f
where f.StartCityID=c1.cityID
and f.endCityID=c2.cityID
and c1.cityName='北京'
and c2.cityName='上海'
3、查询具体某一天(2005-5-8)的北京到上海的的航班次数
select count(*) from
(select c1.CityName,c2.CityName,f.StartTime,f.flightID
from city c1,city c2,flight f
where f.StartCityID=c1.cityID
and f.endCityID=c2.cityID
and c1.cityName='北京'
and c2.cityName='上海'
and 查帮助获得的某个日期处理函数(startTime) like '2005-5-8%'
mysql 中提取日期部分进行比较的示例代码如下：
select * from flight where date_format(starttime,'%Y-%m-%d')='1998-01-02'
15.查出比经理薪水还高的员工信息：
Drop table if not exists employees;
create table employees(id int primary key auto_increment,name varchar(50)
,salary int,managerid int references employees(id));
insert into employees values (null,' lhm',10000,null), (null,' zxx',15000,1
),(null,'flx',9000,1),(null,'tg',10000,2),(null,'wzg',10000,3);
Wzg 大于flx,lhm 大于zxx
解题思路：
根据sql 语句的查询特点，是逐行进行运算，不可能两行同时参与运算。
涉及了员工薪水和经理薪水，所有，一行记录要同时包含两个薪水，所有想到要把这个表自关
联组合一下。
首先要组合出一个包含有各个员工及该员工的经理信息的长记录，譬如，左半部分是员工，
右半部分是经理。而迪卡尔积会组合出很多垃圾信息，先去除这些垃圾信息。
select e.* from employees e,employees m where e.managerid=m.id and e.sala
ry>m.salary;
16、求出小于45 岁的各个老师所带的大于12 岁的学生人数
数据库中有3 个表teacher 表，student 表，tea_stu 关系表。
teacher 表teaID name age
student 表stuID name age
teacher_student 表teaID stuID
要求用一条sql 查询出这样的结果
1.显示的字段要有老师name, age 每个老师所带的学生人数
2 只列出老师age 为40 以下，学生age 为12 以上的记录
预备知识：
1.sql 语句是对每一条记录依次处理，条件为真则执行动作(select,insert,delete,update)
2.只要是迪卡尔积，就会产生“垃圾”信息，所以，只要迪卡尔积了，我们首先就要想到
清除“垃圾”信息
实验准备：
drop table if exists tea_stu;
drop table if exists teacher;
drop table if exists student;
create table teacher(teaID int primary key,name varchar(50),age int);
create table student(stuID int primary key,name varchar(50),age int);
create table tea_stu(teaID int references teacher(teaID),stuID int references student(stuID));
insert into teacher values(1,'zxx',45), (2,'lhm',25) , (3,'wzg',26) , (4,'tg',27);
insert into student values(1,'wy',11), (2,'dh',25) , (3,'ysq',26) , (4,'mxc',27);
insert into tea_stu values(1,1), (1,2), (1,3);
insert into tea_stu values(2,2), (2,3), (2,4);
insert into tea_stu values(3,3), (3,4), (3,1);
insert into tea_stu values(4,4), (4,1), (4,2) , (4,3);
结果：2?3,3?2,4?3
解题思路：(真实面试答题时，也要写出每个分析步骤，如果纸张不够，就找别人要)
1 要会统计分组信息，统计信息放在中间表中：
select teaid,count(*) from tea_stu group by teaid;
2 接着其实应该是筛除掉小于12 岁的学生，然后再进行统计，中间表必须与student 关联才能得
到12 岁以下学生和把该学生记录从中间表中剔除，代码是：
select tea_stu.teaid,count(*) total from student,tea_stu
where student.stuid=tea_stu.stuid and student.age>12 group by tea_stu.teaid
3.接着把上面的结果做成虚表与teacher 进行关联，并筛除大于45 的老师
select teacher.teaid,teacher.name,total from teacher ,(select tea_stu.tea
id,count(*) total from student,tea_stu where student.stuid=tea_stu.stuid and stu
dent.age>12 group by tea_stu.teaid) as tea_stu2 where teacher.teaid=tea_stu2.tea
id and teacher.age<45;
17.求出发帖多的人：
select authorid,count(*) total from articles
group by authorid
having total=
(select max(total2) from (select count(*) total2 from articles group by authorid) as t);
select t.authorid,max(t.total) from
(select authorid,count(*) total from articles )as t
这条语句不行，因为max 只有一列，不能与其他列混淆。
select authorid,count(*) total from articles
group by authorid having total=max(total)也不行。
18、一个用户表中有一个积分字段，假如数据库中有100 多万个用户，若要在每年第一天凌晨
将积分清零，你将考虑什么，你将想什么办法解决?
alter table drop column score;
alter table add colunm score int;
可能会很快，但是需要试验，试验不能拿真实的环境来操刀，并且要注意，
这样的操作时无法回滚的，在我的印象中，只有inert update delete 等DML 语句才能回滚，
对于create table,drop table ,alter table 等DDL 语句是不能回滚。
解决方案一，update user set score=0;
解决方案二，假设上面的代码要执行好长时间，超出我们的容忍范围，那我就alter table user drop
column score;alter table user add column score int 。
下面代码实现每年的那个凌晨时刻进行清零。
Runnable runnable =
new Runnable(){
public void run(){
clearDb();
schedule(this,new Date(new Date().getYear()+1,0,0));
}}
;
schedule(runnable,
new Date(new Date().getYear()+1,0,1));
23、JDBC 中的PreparedStatement 相比Statement 的好处
答：一个sql 命令发给服务器去执行的步骤为：语法检查，语义分析，编译成内部指令，缓存
指令，执行指令等过程。
select * from student where id =3----缓存--?xxxxx 二进制命令
select * from student where id =3----直接取-?xxxxx 二进制命令
select * from student where id =4--- -?会怎么干?
如果当初是select * from student where id =?--- -?又会怎么干?
上面说的是性能提高
可以防止sql 注入。
24. 写一个用jdbc 连接并访问oracle 数据的程序代码
25、Class.forName 的作用?为什么要用?
答：按参数中指定的字符串形式的类名去搜索并加载相应的类，如果该类字节码已经被加载过，
则返回代表该字节码的Class 实例对象，否则，按类加载器的委托机制去搜索和加载该类，如
果所有的类加载器都无法加载到该类，则抛出ClassNotFoundException。加载完这个Class 字节
码后，接着就可以使用Class 字节码的newInstance 方法去创建该类的实例对象了。
有时候，我们程序中所有使用的具体类名在设计时(即开发时)无法确定，只有程序运行时才
能确定，这时候就需要使用Class.forName 去动态加载该类，这个类名通常是在配置文件中配置
的，例如，spring 的ioc 中每次依赖注入的具体类就是这样配置的，jdbc 的驱动类名通常也是通
过配置文件来配置的，以便在产品交付使用后不用修改源程序就可以更换驱动类名。
26、大数据量下的分页解决方法。
答：好的办法是利用sql 语句进行分页，这样每次查询出的结果集中就只包含某页的数据内
容。再sql 语句无法实现分页的情况下，可以考虑对大的结果集通过游标定位方式来获取某页
的数据。
sql 语句分页，不同的数据库下的分页方案各不一样，下面是主流的三种数据库的分页sql：
sql server:
String sql =
"select top " + pageSize + " * from students where id not in" +
"(select top " + pageSize * (pageNumber-1) + " id from students order by id)" +
"order by id";
mysql:
String sql =
"select * from students order by id limit " + pageSize*(pageNumber-1) + "," + pageSize;
oracle:
String sql =
"select * from " +
(select *,rownum rid from (select * from students order by postime desc) where rid<=" +
pagesize*pagenumber + ") as t" +
"where t>" + pageSize*(pageNumber-1);
流行框架面试题
1、什么是MVC模式?
MVC (Model View Controller) 是一个设计模式，使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。M是指数据模型，V是指用户界面，C则是控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以应用于不同的表现形式。
MODEL: 封装了所有的商业逻辑以及规则。通常被JavaBean或EJB实现。
VIEW: 使用商业逻辑处理后的结果并构建呈现给客户端的响应。通常被JSP实现。
CONTROLLER：管理和控制所有用户和应用程序间的交互。通常是一个servlet接收用户的请求并把所有的输入转交给实际工作的MODEL。后调用JSP返回输出。
MVC模式的好处：
1.各施其职，互不干涉
在MVC模式中，三个层各施其职，所以如果一旦哪一层的需求发生了变化，就只需要更改相应的层中的代码而不会影响到其它层中的代码。
2.有利于开发中的分工
在MVC模式中，由于按层把系统开，那么就能更好的实现开发中的分工。网页设计人员可以进行开发视图层中的JSP，对业务熟悉的开发人员可开发业务层，而其它开发人员可开发控制层。
3.有利于组件的重用
分层后更有利于组件的重用。如控制层可独立成一个能用的组件，视图层也可做成通用的操作界面。
Struts就是一个基于MVC模式的框架。
请描述一下Struts2的值栈结构，以及它是如何工作的?
值栈 Value Stack
值栈是Struts2框架的核心概念。所有的核心组件都以某种方式与之进行交互，它提供对上下文信息和执行环境中元素的访问机制。值栈的内容由如下4个层级组成。
1.临时对象
这些对象在请求处理中需要临时保存，比如集合中当前正在被迭代的元素。
2.模型对象
当action实现了ModelDriven接口，模型对象就会被存放在栈中，在action对象前。如果action没有实现该接口，这个级别的内容将不存在。
3.Action对象
此对象是当前正在执行的action。
4.命名对象 即 OGNL上下文环境
任何对象都可以被赋予一个标识符而成为命名对象。Struts2内建的命名对象有：#application、#session、#request、#attr、#parameters
使用值栈不需要压栈和弹栈，可直接使用OGNL表达式来查找或求值。OGNL表达式会在每个层级测试，层级测试的顺序按照层级顺序进行。如果各层级都没有求出结果，那么则返回null值。
Struts2里面有什么隐式对象?
Struts 2.1 的隐式对象
(这些隐式对象都是Map类型)
parameters 用于访问请求参数
request 用于访问HttpServletRequest的属性
session 用于访问HttpSession的属性
application 用于访问ServletContext的属性
attr 用于访问各作用域内的属性，将依次搜索 request > session > application
Struts2的Action中获取request对象的几种方式?
1.通过ActionContext.getSession获取
2.通过ServletActionContext.getRequest()获取
3.通过SessionAware接口注入
4.通过ServletRequestAware接口注入
请说说你对Struts2的拦截器的理解。
Struts2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是AOP的一种实现.
拦截器栈(Interceptor Stack)类似于过滤器链。拦截器栈就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器栈的拦截器就会按其之前定义的顺序被调用。
Struts2的拦截器和Filter类似。在执行Action的execute方法之前，Struts2会首先执行在struts.xml中引用的拦截器，完成一系列的功能，在执行完所有引用的拦截器的intercept方法后，会执行Action的execute方法。
6.什么是ORM思想?常用的基于ORM的框架有哪些?各有什么特点?
ORM的全称是Object-Relational Mapping，即对象关系映射。ORM思想的提出来源于对象与关系之间相悖的特性。我们很难通过对象的继承与聚合关系来描述数据表中一对一、一对多以及多对多的关系。而面向对象思想中有关抽象与多态的原理，也无法通过关系数据库的SQL语句得以彰显。因此，我们需要在面向对象与面向关系之间找到一个平衡点，ORM于是应运而生。
目前ORM框架的产品非常之多，除了个大公司、组织的产品外，其他一些小团队也在推出自己的ORM框架。目前流行的ORM框架有如下这些产品：
(1)Enitiy EJB：Enitiy EJB实际上也是一种ORM技术，这是一直备受争议的组件技术。事实上，EJB为Java EE的蓬勃发展赢得了极高的声誉，EJB作为一种重量级、高花费的ORM技术具有不可比拟的优势。就其他架构设计来讲，依然非常优秀。即使现在十分流行的轻量级Java EE架构，其实质是对经典Java EE架构的模仿——虽然存在些许的改进。EJB3.1也采取了低侵入式的设计，增加了Annotation，也具有极大的吸引力。
(2)Hibernate：目前流行的开源ORM框架，已经被选作JBoss的持久层解决方案。整个HIbernate项目也一并投入了Jboss的怀抱，而JBoss又加入了RedHat组织，所以现在Hibernate属于RedHat 的一部分。Hibernate 灵巧的设计、优秀的性能，还有其丰富的文档都是其风靡全球的重要因素。
(3)iBatis： Apache软件基金组织的子项目。与其称它为一种ORM框架，不如称它为一中“SQL Mapping”框架。曾经在J2EE的开发中扮演非常重要的角色，但因为不支持存粹的面向对象操作，因此现在逐渐地被取代。但是在一些公司，依然占有一席之地，特别是一些对数据访问特别灵活的地方，iBatis更加的灵活，它允许开发人员直接编写SQL语句。
(4)TopLink：Oracle公司的产品，作为一个遵循OTN协议的商业产品，TopLink 在开发过程中可以自由地下载和使用，但是一旦作为商业产品被使用，则需要收取费用。由于这一点，TopLink 的市场占有率不高。
(5)OBJ：Apache软件基金组织的子项目。另一个开源的ORM框架，可以说是Apache作为iBatis之后的取代产品，也是非常优秀的O/R Mapping框架，但是由于Hibernate 的广芒太盛，所以并未有广泛的使用，而且由于OJB的开发文档不是很多，这也影响了OJB的流行。
7 .请说说你对Hibernat的理解?JDBC和Hibernate各有什么优势和劣势?
Hibernate是一个轻量级的持久层开源框架,它是连接Java应用程序和关系数据库的中间件,负责Java对象和关系数据之间的映射.Hibernate内部对JDBC API进行了封装,负责Java对象的持久化.因为它封装了所有的数据访问细节,使得业务逻辑层可以专注于实现业务逻辑.
它是一种优秀的ORM映射工具,提供了完善的对象-关系映射服务,开发过程不依赖容器,灵活性非常大,可以无缝集成到任何一个java系统中.
JDBC和Hibernate都是用于数据持久化操作的。
JDBC:
1.实现业务逻辑的代码和访问数据库的代码混杂在一起,使程序结构不清晰,可读性差.
2.Java是面向对象的,sql是面向关系的.两者混在一起,程序员不能完全的运用面向对象的思维来编写程序.
3.业务逻辑和关系数据模型绑定,如果关系数据模型发生变化(如更改表结构),就必须手动修改程序里所有相关的sql语句,增加了维护软件的难度.如果sql语句有语法错误,编译是不能检查这种错误,只有运行时才能发现错误,增加了程序的调试难度.
4.数据库移植困难。
Hibernate：
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
