面试题目

最近面试，遇到了一些题目，记下来。

项目访问量？

项目访问量，也叫页面浏览量（ PV(page view)），我所在的项目，大概有1000W的PV，成交量在每天20-30W单。

平均访问量QPS(Query Per Second) ，每秒查询量。总PV/有效时间。1000W/(16*60*60)=173.6111111111111

16为16小时

socket的使用？

直接使用socket很少，进程间的通信通常使用hessian、netty、mina等框架

bio、nio、AIO

bio：blocking IO，阻塞IO。单线程，阻塞；IO操作未完成，线程不可进行其它操作。多线程，占用资源。JDK1.4之前用

nio：non-blocking IO，非阻塞IO

BIO与NIO都是同步的

MyBatis在mysql、oracle分页？

SELECT * FROM 
(
SELECT A.*, ROWNUM RN 
FROM (SELECT * FROM TABLE_NAME) A 
WHERE ROWNUM <= 40
)
WHERE RN >= 21

其中最内层的查询SELECT * FROM TABLE_NAME表示不进行翻页的原始查询语句。ROWNUM <= 40和RN >= 21控制分页查询的每页的范围。

上面给出的这个分页查询语句，在大多数情况拥有较高的效率。分页的目的就是控制输出结果集大小，将结果尽快的返回。在上面的分页查询语句中，这种考虑主要体现在WHERE ROWNUM <= 40这句上。

选择第21到40条记录存在两种方法，一种是上面例子中展示的在查询的第二层通过ROWNUM <= 40来控制最大值，在查询的最外层控制最小值。而另一种方式是去掉查询第二层的WHERE ROWNUM <= 40语句，在查询的最外层控制分页的最小值和最大值。这是，查询语句如下：

SELECT * FROM 
(
SELECT A.*, ROWNUM RN 
FROM (SELECT * FROM TABLE_NAME) A 
)
WHERE RN BETWEEN 21 AND 40

对比这两种写法，绝大多数的情况下，第一个查询的效率比第二个高得多。

这是由于CBO优化模式下，Oracle可以将外层的查询条件推到内层查询中，以提高内层查询的执行效率。对于第一个查询语句，第二层的查询条件WHERE ROWNUM <= 40就可以被Oracle推入到内层查询中，这样Oracle查询的结果一旦超过了ROWNUM限制条件，就终止查询将结果返回了。

而第二个查询语句，由于查询条件BETWEEN 21 AND 40是存在于查询的第三层，而Oracle无法将第三层的查询条件推到最内层（即使推到最内层也没有意义，因为最内层查询不知道RN代表什么）。因此，对于第二个查询语句，Oracle最内层返回给中间层的是所有满足条件的数据，而中间层返回给最外层的也是所有数据。数据的过滤在最外层完成，显然这个效率要比第一个查询低得多。

Hibernate、Mybatis技术选型？

项目大小（大mybatis,小hibernate），二次开发(mybatis更灵活)

mybatis细精度优化，数据超过万条，mybatis更快一些

都是ORM（对象关系映射）框架。hibernate是全自动，增删改查都是操作对象，返回结果也是对象。其实，为了使增、删、改，特别是查更灵活，这些操作更倾向于使用sql，而将查询结果封装成对象，这就是Mybaits所谓的半自动化。

left join,right join,inner join,full join哪个效率更高？

inner join>left join=right join>full join

LEFT JOIN 不管怎么样是把左边的表整体放到MEMORY里面去运算。
INNER JOIN是过滤了一遍，然后把相同的结果放到MEMORY里面去运算。

 多线程在编写的时候应该注意什么？多线程如何使用？

使用线程池，通过 ThreadPoolExecutor去创建。

ThreadPoolExecutor构造函数如下：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 corePoolSize 代表该线程中允许的核心线程数，要和工作的线程数量区分开来，两者不 

                      等价(工作的线程数量一定不大于corePoolSize，即当超过后，会将线程
                      放入队列中)，可以理解为一个ArrayList集合中，默认空间是10,但存放的 
                     元素的数量 不一定是10， 在这里这个10就寓指corePoolSize ，存放元
                     素的个数是工作线程数量 

少于corePoolSize，就创建核心线程。超过时，就放入workQueue ，workQueue 放不下时，就创建线程，除非创建此线程超出 maximumPoolSize，在这种情况下，任务将被拒绝。

maximumPoolSize 这个参数的意思就是该线程池所允许的最大线程数量
keepAliveTime 这个参数的意思就是空余线程的存活时间，注意这个值并不会对所有线程起作用，如果线程池中的线程数少于等于核心线程数 corePoolSize，那么这些线程不会因为空闲太长时间而被关闭，当然，也可以通过调用allowCoreThreadTimeOut方法使核心线程数内的线程也可以被回收。

unit 时间单位
workQueue 阻塞队列，在此作用就是用来存放线程。
threadFactory 线程工厂
defaultHandler 拒绝策略，即当加入线程失败，采用该handler来处理

如下代码的执行目的是执行15个任务

1、核心池大小是6，workQueue是5。所以首选创建6个线程，来执行任务

2、当第7-11个任务过来时，放入workQueue

3、第12-15个任务过来，workQueue放不下了，这时创建新线程去执行。这时7-11还在queue中

4、当有线程执行完任务是，开始执行workQueue中的任务

5、最终，全部任务执行完毕

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.*;
import java.util.*;


public class ThreadPoolExecutorTest {

	public static void main(String[] args) {

        //设置核心池大小
        int corePoolSize = 6;

        //设置线程池最大能接受多少线程
        int maximumPoolSize = 100;

        //当前线程数大于corePoolSize、小于maximumPoolSize时，超出corePoolSize的线程数的生命周期
        long keepActiveTime = 200;

        //设置时间单位，秒
        TimeUnit timeUnit = TimeUnit.SECONDS;

        //设置线程池缓存队列的排队策略为FIFO，并且指定缓存队列大小为5
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<Runnable>(5);

        //创建ThreadPoolExecutor线程池对象，并初始化该对象的各种参数
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepActiveTime, timeUnit,workQueue);

        //往线程池中循环提交线程
        for (int i = 0; i < 15; i++) {
            //创建线程类对象
            MyTask myTask = new MyTask(i);
            //开启线程
            executor.execute(myTask);
            //获取线程池中线程的相应参数
            System.out.println("线程池中线程数目：" +executor.getPoolSize() + "，队列中等待执行的任务数目："+executor.getQueue().size() + "，已执行完的任务数目："+executor.getCompletedTaskCount());
        }
        //待线程池以及缓存队列中所有的线程任务完成后关闭线程池。
        executor.shutdown();
    }


}

import java.text.*;
import java.util.*;


public class MyTask implements Runnable {

	 private int num;

	    public MyTask(int num) {
	        this.num = num;
	    }

	    @Override
	    public void run() {
	        System.out.println("正在执行task " + num );
	        try {
	            Thread.currentThread().sleep(5000);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	        System.out.println("task " + num + "执行完毕");
	    }


}

【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

1）FixedThreadPool 和 SingleThreadPool:

允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

2）CachedThreadPool 和 ScheduledThreadPool:

允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

解决方案：

1、使用ThreadFactoryBuilder（谷歌guava框架） 

2、spring也提供了相似的工具

参见https://blog.csdn.net/more_try/article/details/81506501

不再建议程序员使用较为方便的 Executors 工厂方法 Executors.newCachedThreadPool()（*线程池，可以进行自动线程回收）、Executors.newFixedThreadPool(int)（固定大小线程池）和 Executors.newSingleThreadExecutor()（单个后台线程），它们均为大多数使用场景预定义了设置

 在java中大致有这几种线程池

 newCachedThreadPool：

创建一个可缓存线程池

优点：很灵活，弹性的线程池线程管理，用多少线程给多大的线程池，不用后及时回收，用则新建

缺点：一旦线程无限增长，会导致内存溢出。

newFixedThreadPool ：

优点：创建一个固定大小线程池，超出的线程会在队列中等待。

缺点：不支持自定义拒绝策略，大小固定，难以扩展

newScheduledThreadPool ：

优点：创建一个固定大小线程池，可以定时或周期性的执行任务。

缺点：任务是单线程方式执行，一旦一个任务失败其他任务也受影响

newSingleThreadExecutor ：

优点：创建一个单线程的线程池，保证线程的顺序执行

缺点：不适合并发。。不懂为什么这种操作要用线程池。。为什么不直接用队列

统一缺点：不支持自定义拒绝策略。

泛型的使用？

 泛型，即“参数化类型”,将类型由原来的具体的类型参数化。泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

泛型,让类型更灵活，同时也可在编译时限制。增加程序员编程的便捷性以及安全性而创建的一种机制。

虚拟机中没有泛型，只有普通类和普通方法

所有泛型类的类型参数在编译时都会被擦除

创建泛型对象时请指明类型，让编译器尽早的做参数检查

struts工作流程？

springMVC工作流程？

http://www.iteye.com/news/32924

用户发送请求至前端控制器DispatcherServlet 
· DispatcherServlet收到请求调用HandlerMapping处理器映射器。 
· 处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。 
· DispatcherServlet通过HandlerAdapter处理器适配器调用处理器 
· 执行处理器(Controller，也叫后端控制器)。 
· Controller执行完成返回ModelAndView 
· HandlerAdapter将controller执行结果● ModelAndView返回给DispatcherServlet 
· DispatcherServlet将ModelAndView传给● ViewReslover视图解析器 
· ViewReslover解析后返回具体View 
· DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）。 
· DispatcherServlet响应用户。 
从上面可以看出，DispatcherServlet有接受请求，响应结果，转发等作用。有了DispatcherServlet之后，可以减少组件之间的耦合度。 

spring IOC\AOP？

IOC(Inversion of Control)控制反转，是通过DI（Dependency Injection）来实现的。是Spring的核心，Spring之所以叫做Spring容器，就是因为Spring能通过IOC来进行bean的管理。Spring来负责控制对象的生命周期和对象间的关系。

比如controller层，依赖于service层，DI就将service的实例注入到controller中，不需要在controller中创建service实例。

IOC的实现原理是：工厂+反射，根据配置，动态创建出对象。

AOP的实现原理是动态代理

缓存技术？

memcache、redis

分布式事务

分布式事务可以使用MyCat

三段式提交

（1）CanCommit 阶段：三阶段提交的 CanCommit 阶段其实和二阶段提交的准备阶段很像，协调者向参与者发送 commit 请求，参与者如果可以提交就返回 Yes 响应，否则返回 No 响应。 
（2）PreCommit 阶段：协调者根据参与者的反应情况来决定是否可以记录事务的 PreCommit操作。根据响应情况，有以下两种可能。

• 假如协调者从所有参与者那里获得的反馈都是 Yes 响应，则执行事务。
• 假如有任何一个参与者向协调者发送了 No 响应，或者等待超时之后协调者都没有接到参与者的响应，则执行事务的中断。

（3）DoCommit阶段：该阶段进行真正的事务提交，也可以分为执行提交、中断事务两种执行情况。

 执行提交的过程如下。

• 协调者接收到参与者发送的ACK响应后，将从预提交状态进入提交状态，并向所有参与者发送doCommit请求。
• 事务提交参与者接收到doCommit请求之后，执行正式的事务提交，并在完成事务提交之后释放所有的事务资源。
• 事务提交完之后，向协调者发送ACK响应。
• 协调者接收到所有参与者的ACK响应之后，完成事务。中断事务的过程如下。
• 协调者向所有参与者发送abort请求。
• 参与者接收到 abort 请求之后，利用其在第 2 个阶段记录的 undo 信息来执行事务的回滚操作，并在完成回滚之后释放所有的事务资源。
• 参与者完成事务回滚之后，向协调者发送 ACK 消息。
• 协调者接收到参与者反馈的 ACK 消息之后，执行事务的中断。

HashMap实现分析（源码）

HashMap 的实例有两个参数影响其性能：初始容量（默认16） 和加载因子（默认.75）。

当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构）

在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。

若很多映射关系要存入HashMap中，在创建之初，可以设置较大的初始容量， 用来减少rehash操作

HashMap是非线程安全的，

• 如果多个线程同时访问哈希映射，并且至少有一个线程在结构上修改了映射，那么它必须在外部进行同步。 （结构修改是指添加或删除一个或多个映射的任何操作;仅改变与实例已经包含的**相关联的值不是结构修改。）这通常通过对自然地封装映射的一些对象进行同步来实现。 如果没有这样的对象存在，应该使用Collections.synchronizedMap方法“包装”。 这最好在创建时完成，以防止意外的不同步访问地图：

    Map m = Collections.synchronizedMap(new HashMap(...)); 

 由所有此类的“collection 视图方法”所返回的迭代器都是快速失败（faile-fast） 的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间发生任意不确定行为的风险。 下面这句话比较顺

如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。

数据结构：数组+链表/红黑树

ArrayList源码实现：数组

链表分为单向链表与双向链表。LinkedList为双向链表，存储有上一个节点和下一个节点的Node。

1、初始化

resize()：创建newCap大小的数组

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

 2、赋值

putVal()

a)hash碰撞，若碰撞不上，入数组

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

 key的Hash值为HashCode运算得到的，高16位不变，然后高16位与低16位想异或。异或得到0或1的比例为50%。这样做的目的是将数组填满。

hash(key)

return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);

b)若碰撞上了，且Key相同，替换value。

c)若碰撞上了，且Key不同，入链表

p.next = newNode(hash, key, value, null);

d)若链表长度超过阀值（8），则将链表改为红黑树

TREEIFY_THRESHOLD = 8

e)若map里存储数据大小超过阀值=数组初始大小*加载因子，则扩容

if (++size > threshold)
    resize();

不超过初始化最大容量（MAXIMUM_CAPACITY），则扩容两倍

newThr = oldThr << 1; 

扩容后，遍历原map,对新map赋值

//元素后无值情况
newTab[e.hash & (newCap - 1)] = e;
//红黑树情况 
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//链表情况

3、取值

三种情况：在数组中、在链表中、在红黑树中

数组：

if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
    return first;

 链表:

do {
    if (e.hash == hash &&
        ((k = e.key) == key || (key != null && key.equals(k))))
        return e;
} while ((e = e.next) != null);

红黑树：

if (first instanceof TreeNode)
    return ((TreeNode<K,V>)first).getTreeNode(hash, key);

 HashMap如何顺序存储与读取？线程安全Map?

可以使用LinkedHashMap，它维护着一个运行于所有条目的双向链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（插入顺序）

如下代码会输出一些null，此代码不能说明HashMap是非线程安全的。

开5个线程存，5个线程取，会出去环形链接，这是非线程安全的正确测试方法，后续补充

new Thread(new Runnable() {
    @Override
public void run() {
        for(int i=0;i < 100000;i++){
            map.put(i,"aa"+i*56732);
         }
    }
}).start();

new Thread(new Runnable() {
    @Override
public void run() {
        for(int i=0;i < 10000;i++){
            System.out.println(i+":"+map.get(i));
        }
    }
}).start();

 HashTable是线程安全的，它会在get和put方法上，加上synchronized。锁的粒度粗，影响性能

CurrentLinkList源码，数组与链表的性能比较

分布式锁

http://chenjinbo1983.iteye.com/blog/2432174

java性能调优

JVM调优，其余待补充

Jconsole调试工具 ,jemeter

zookeeper的使用

多线程回调

10W个数，取最大的那个

Collections.max()是这样做的：遍历，最大的赋给变量

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {

Iterator<? extends T> i = coll.iterator();

T candidate = i.next();

        while (i.hasNext()) {

    T next = i.next();

    if (next.compareTo(candidate) > 0)

candidate = next;

}

return candidate;

    }

10W个数，取最大的10个

1、分成100份，一份100个数

2、每份找10个最大的

3、100份，再合并比较，找出最大的

10W个数，找出现次数最数最多的10个

netty聊天室，设计思路？未读数

常用集合？List下发些常用类？线程安全List?

用过哪些队列？队列提交方式？Future是什么？

netty，mina技术选型？

sql explain如何用？

表中，ABC三个字段创建索引。只查询AB是否会命中这个索引？

mysql分库分表

数据库扩展性：
1、scale up 向上升级，硬件升级

2、scale out向外升级、水平扩展，加节点

数据库拆分：垂直拆分和水平拆分

垂直拆分：表结构发生变化

拆字段、拆表、拆数据库

1个字段拆出两个表或多个表，一个表拆出两个或多个表，1个数据库拆出多个库

拆分原因：

1、磁盘空间不够

show global variables like "%datadir%"; -- 查看数据存储路径

du -csh * -- 进入操作系统相应目录，查目录大小

2、某个模块或某些表负载过大

3、某个业务模块需迁移

迁移方法：主从

水平拆分：根据高标识字段进行拆分

实现方式

1、对字段取模

2、按照范围：时间、范围

3、按照用户自定义哈希函数

拆分时，标识字段相同的数据，在同一个分片上，尽量不使用分布式事务。这样可以用Join，和事务。

设计一个大型分布式架构

数据库层分库分表（根据服务不同，进行分库。同时数据量大的表，进行分库分表）

应用层，采用微服务架构。底层多个服务，服务与数据库之间有缓存层。服务层上，是具体业务层。

HTTP请求报头和响应报头中的内容？

https://blog.csdn.net/u010256388/article/details/68491509

HTTP请求报文由3部分组成（请求行+请求头+请求体）：

请求行包含：请求方法（get、post）、请求地址、请求的协议（HTTP/1.1）

请求头包含：

        Accept：客户端接受什么类型的响应，如text/plain、image/png。Accept属性的值可以为一个或多个MIME类型

       Cookie：客户端Cookie，由之前服务器通过Set-Cookie设置的一个HTTP协议Cookie

       Referer：请求是从哪个URL过来的，假如你通过google搜索出一个商家的广告页面，你对这个广告页面感兴趣，鼠标一点发送一个请求报文到商家的网站，这个请求报文的Referer报文头属性值就是http://www.google.com

       Cache-Control：用来指定当前的请求/回复中的，是否使用缓存机制。如：Cache-Control: no-cache

       Host：表示服务器的域名以及服务器所监听的端口号

       User-Agent：浏览器的身份标识字符串，如Mozilla/5.0 (Windows NT 6.1; W…) Gecko/20100101 Firefox/60.0

       Accept-Charset：字符集，例如 ISO-8859-1

       Accept-Encoding： 编码方式，如gzip 或 compress

session共享（一致性）

对于分布式系统，如何保证Session一致性。

1、使用nginx的IP_hash，但有缺点，如nginx必须位于最前端，新增节点，需修改Nginx配置

2、session后端存储，可以存在缓存或数据库中。建议存缓存中。缺点是，需多调用一次

也可以使用cookie或session同步，但个人建议使用缓存。

怎么看ofo、mobike

技术上，地图，大并发

有成就感的事件？

点对点通信，亚信、联创接口封装
EOMS动态表单

Android自学半个月，然后第一个月就完成一个Android项目

攻克了什么技术难点？

spring boot spring cloud

我对自己的评价

能带团队、能独立完成项目、有系统设计能力

UML的使用？

UML可以用visio,rose画

UML有六大关系？

UML定义的关系主要有六种：依赖、类属、关联、实现、聚合和组合。这些类间关系的理解和使用是掌握和应用UML的关键，而也就是这几种关系，往往会让初学者迷惑。这里给出这六种主要UML关系的说明和类图描述，一看之下，清晰明了；以下就分别介绍这几种关系：

    继承

    指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性；

    实现

    指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性；

    依赖

    可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需 要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method方法中使用；

    关联

    他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一 般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B以类属性的形式出现在关联类A中，也可能是关联类A引 用了一个类型为被关联类B的全局变量；

    聚合

    聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU 、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

    组合

    组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体 与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分；

    对于继承、实现这两种关系没多少疑问，他们体现的是一种类与类、或者类与接口间的纵向关系；其他的四者关系则体现的是类与类、或者类与接口间的引用、横向 关系，是比较难区分的，有很多事物间的关系要想准备定位是很难的，前面也提到，这几种关系都是语义级别的，所以从代码层面并不能完全区分各种关系；但总的 来说，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖。

UML中有九种建模的图标，即：
•用例图
•类图
•对象图
•顺序图(时序图)
•协作图
•状态图
•活动图
•组件图
•配置图

springMVC和struts2比较？

项目刚刚换了web层框架，放弃了struts2改用springMvc 
当初还框架的时候目的比较单纯---springmvc支持rest，小生对restful url由衷的喜欢
不用不知道 一用就发现开发效率确实比struts2高 
我们用struts2时采用的传统的配置文件的方式，并没有使用传说中的0配置 
springMvc可以认为已经100%零配置了（除了配置springmvc-servlet.xml外） 
比较了一下strus2与spring3 mvc的差别 ?
struts2框架是类级别的拦截 ，每次来了请求就创建一个Action，然后调用setter getter方法把request中的数据注入 
struts2实际上是通过setter getter方法与request打交道的 
struts2中，一个Action对象对应一个request上下文 
springMvc不同，springMvc是方法级别的拦截 ，拦截到方法后根据参数上的注解，把request数据注入进去 
在springMvc中，一个方法对应一个request上下文 
好了 我们来整理一下 
struts2是类级别的拦截 ， 一个类对应一个request上下文， 
springMvc是方法级别的拦截 ，一个方法对应一个request上下文，而方法同时又跟一个url对应 
所以说从架构本身上 springMvc就容易实现restful url 
而struts2的架构实现起来要费劲 
因为struts2 action的一个方法可以对应一个url 
而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了

项目中异常的使用？

1. 异常机制 
      异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。

每个类型的异常的特点 
Error体系 ： 
      Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形。应用程序不应该抛出这种类型的对象（一般是由虚拟机抛出）。如果出现这种错误， 除了尽力使程序安全退出外，在其他方面是无能为力的。所以，在进行程序设计时，应该更关注Exception体系。

Exception体系包括RuntimeException体系和其他非RuntimeException的体系 ： 
① RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。处理 RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界 来避免数组越界访问异常。 
②其他非RuntimeException（IOException等等）：这类异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。