找工作的时候做的Java面试整理

找工作的时候做的Java面试整理，前前后后面了很多家吧，做一个整理把一些常问的还有基础的以及项目中要问的做了如下整理，特别需要注意的知识点：

多线程

数据库（SQL 优化，索引，引擎，事务）

数据结构

1 spring ioc ，aop 的原理

春天IOC 依赖注入其实就是控制反转，用春天时用XML 配置的方式的话，都是将豆配置在春天中，也有豆的财产属性。春天容器在初始化时就通过反射将容器中的豆实例化，假如豆配置中有属性属性，就会反射属性属性注入到bean 中。这就是依赖注入。它分为构造方法注入，设置方法注入，接口注入，我们最常用的就是设置方法注入

spring AOP ：AOP 就是面向切面编程。它主要运用了动态代理中的Proxy 类和InvicationHandler 接口实现。举例简单来说假如想要在原来的目标类的前后要加入日志的功能，目标类一定要实现一个接口，如果没有实现接口，spring 就会用cglib 包实现AOP 。推荐的还是要实现一个接口。实现过程大概就是实现了一个InvicationHandler 接口的方法，里边有一个属性是目标类，在invoke 方法中利用反射执行目标类的方法，并在其前后加入日志的方法。然后将目标类的类加载器，目标类实现的接口和实现了InvicationHandler 接口的方法传入到代理服务器的的newProxyInstance 方法中。这样就实现了AOP 。这样的话我们就可以在不修改任何代码的情况下在任何目标类中都可以动态的加入记日志的功能。

2 hibernate 延迟加载原理

lazy =“true”，则代表对对象实施延迟加载，即，使用加载函数返回由CGLIB 或者javaassist产生的代理对象，a。当不需要取得对象（非主键属性）时，不真正载入内存，从而节约内存空间，并且可以减少对数据的访问频率，高效的返回查询的对象; b。当需要取得对象（非主键属性）时，hibernate 会先从会话缓存寻找，再从二级缓存寻找，都找不到，才会使用选择语句访问数据库。

3 事务隔离级别什么情况下用低的或者用高的

（事务（事务）是访问并可能更新数据库中各种数据项的一个程序执行单元（单元））

事务隔离级别指的是事务与事务之间的隔离程度，事务隔离程度越高，并发性越差，性能越低;事务隔离程度越低，并发性越强，性能越高。

4 事务传播方式哪几种

新建事务

必需- 如无事务就新建事务

required_new 如有事务挂起当前事务再新建

非事务方式运行

Supports 支持当前事务，如果当前没有事务，就以非事务方式执行。

not_supported - 挂起当前

never

嵌套事务：

Nested 如果当前事务存在，则以嵌套事务的方式执行。否则就按照它自己的事务方式执行。

抛异常

mandatory 支持当前事务，如果当前没有事务，就抛出异常

never 非事务方式执行，如果当前存在事务，则抛出异常。

5 ajax 跨域如何实现

ajax跨域调用有两种方式，一种是iframe的方式，通过设置document.domain来实现，一种则是通过设置jsonp来实现

7 乐观锁与悲观锁，举例场景

1、悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，加锁机制，也无法保证外部系统不会修改数据即使在本系统中实现了）。

2、乐观锁（ Optimistic Locking ）

相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。

8 cookie 与session 区别和联系，http 协议是无状态的，怎么区分不同登录用户

Cookie 与session的区别:

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

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

3、session不能区分路径，同一个用户在访问一个网站期间，所有的session在任何一个地方都可以访问到。而cookie中如果设置了路径参数，那么同一个网站中不同路径下的cookie互相是访问不到的。

区分不同登录用户:

session就是一种保存上下文信息的机制，它是针对每一个用户的，变量的值保存在服务器端，通过SessionID来区分不同的客户.

9 阐述opensessionview一下，用和不用数据库连接、transaction session 之间开启和关闭顺序

1.说说值对象与引用对象的区别？

值对象描述了一种不可变的对象，这些对象完全由其所含的数据值在定义，并不介意副本的存在。

引用对象描述了一种可以被共享（复用）的对象，这些对象的类往往在设计之初就考虑到共享的可能性或者打算用于共享。每个对象对应一个抽象化的实体，这个实体会被多次引用，并且希望这些引用对应一个相同的实例，通过任何一个引用都可以使用或改变这个对象的状态。可以使用相等操作符（==）检查两个对象是否相等

2.谈谈你对反射机制的理解及其用途？

Java反射机制主要提供了以下功能：在运行时构造一个类的对象；判断一个类所具有的成员变量和方法；调用一个对象的方法；生成动态代理。

主要用途是：通过传递一个字符串值去调用某一个类的方法。例如根据spec0去调用SpecValue下的setSpce0（）方法。

3.ArrayList、Vector、LinkedList的区别及其优缺点？HashMap、HashTable的区别及其优缺点？

ArrayList,LinkedList是不同步的，而Vestor是同步的。所以如果不要求线程安全的话，可以使用ArrayList或LinkedList，可以节省为同步而耗费的开销。但在多线程的情况下，有时候就不得不使用Vector了。
ArrayList和Vector都是使用Object的数组形式来存储的。Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,
ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。\

hashMap,hashTable的区别:

HashTable 中的方法是同步的 HashMap的方法在缺省情况下是非同步的因此在多线程环境下需要做额外的同步机制

HashTable不允许有null值 key和value都不允许，而HashMap允许有null值 key和value都允许因此HashMap 使用containKey（）来判断是否存在某个键

HashTable 使用Enumeration ，而HashMap使用iterator

Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类

3.列出线程的实现方式？如何实现同步？

线程的实现方式有两种：实现Runnable接口或者继承Thread类

实现同步的方法也有两种：一种是用同步方法，一种是用同步块 wait()与notify()

同步方法就是在方法返回类型后面加上synchronized

同步块就是直接写synchronized（这里写需要同步的对象）{}

4. 如何实现线程安全、高可用的hashMap

方法一:通过Collections.synchronizedMap()返回一个新的Map,这个新的map就是线程安全的. 是一种悲观锁.在进入之前需要获得锁,确保独享当前对象,然后做相应的修改/读取. 这个要求大家习惯基于接口编程,因为返回的并不是HashMap,而是一个Map的实现.

方法二:重新改写了HashMap, 使用的是乐观锁,只有在需要修改对象时,比较和之前的值是否被人修改了,如果被其他线程修改了,那么就会返回失败.

5. 条件查询慢如何优化

索引分区（垂直水平）缓存表优化 SQL优化

6.String的indexof 的实现

先把String转换为char[]，然后首先找到target的的第一个字符开始匹配.

7. 重写equal 的同时为什么必须重写hashcode？

hashCode是编译器为不同对象产生的不同整数，根据equal方法的定义：如果两个对象是相等（equal）的，那么两个对象调用hashCode必须产生相同的整数结果，即：equal为true，hashCode必须为true，equal为false，hashCode也必须为false，所以必须重写hashCode来保证与equal同步。

8. 判断两个对象是否相等

(1)判断两个对象的hashCode是否相等

如果不相等，认为两个对象也不相等，完毕

如果相等，转入2

(2)判断两个对象用equals运算是否相等

如果不相等，认为两个对象也不相等

如果相等，认为两个对象相等

9. 为什么要重载equal方法？

因为Object的equal方法默认是两个对象的引用的比较，意思就是指向同一内存,地址则相等，否则不相等；如果你现在需要利用对象里面的值来判断是否相等，则重载equal 方法

10.为什么重载hashCode方法？

答案：一般的地方不需要重载hashCode，只有当类需要放在HashTable、HashMap、HashSet等等hash结构的集合时才会重载hashCode，就HashMap来说，好比HashMap就是一个大内存块，里面有很多小内存块，小内存块里面是一系列的对象，可以利用hashCode来查找小内存块hashCode%size(小内存块数量)，所以当equal相等时，hashCode必须相等，而且如果是object对象，必须重载hashCode和equal方法。

11. 为什么equals()相等，hashCode就一定要相等，而hashCode相等，却不要求equals相等?

(1)因为是按照hashCode来访问小内存块，所以hashCode必须相等。

(2)HashMap获取一个对象是比较key的hashCode相等和equal为true。

之所以hashCode相等，却可以equal不等，就比如ObjectA和ObjectB他们都有属性name，那么hashCode都以name计算，所以hashCode一样，但是两个对象属于不同类型，所以equal为false。

12、为什么需要hashCode?

(1)通过hashCode可以很快的查到小内存块。

(2)通过hashCode比较比equal方法快，当get时先比较hashCode，如果hashCode不同，直接返回false。

13. sleep和wait有什么区别

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，

wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者

14. InputStream和Reader的区别

InputStream和Reader都是java.io下的抽象类. InputStream是表示字节输入流的所有类的超类. Reader是用于读取字符流的抽象类. InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组.

15. UNICODE,GBK,UTF-8区别

unicode，gbk和大五码就是编码的值，而utf-8,uft-16之类就是这个值的表现形式．而前面那三种编码是一兼容的，同一个汉字，那三个码值是完全不一样的．如＂汉＂的uncode值与gbk就是不一样的，假设uncode为a040，gbk为b030，而uft-8码，就是把那个值表现的形式．utf-8码完全只针对uncode来组织的，如果ＧＢＫ要转ＵＴＦ－８必须先转uncode码，再转utf-8就ＯＫ了．

16. 字节流与字符流的区别

在java.io包中操作文件内容的主要有两大类：字节流、字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输入使的是InputStream，在字符流中输出主要是使用Writer类完成，输入流主要使用Reader类完成。

字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点

17.对excel操作的两种方法

一种是使用jxl.jar,另一种是使用poi.jar

两者的区别:

Poi 主要是提供一组操作windows文档的Java API.

JavaExcel俗称jxl是一开放源码项目，通过它Java开发人员可以读取Excel文件的内容、创建新的Excel文件、更新已经存在的Excel文件。

jxl优点：

Jxl对中文支持非常好，操作简单，方法看名知意。

Jxl是纯javaAPI，在跨平台上表现的非常完美，代码可以再windows或者Linux上运行而无需重新编写

生成Excel 2000标准格式

支持字体、数字、日期操作

能够修饰单元格属性

支持图像和图表,但是这套API对图形和图表的支持很有限，而且仅仅识别PNG格式。

缺点：效率低，图片支持不完善，对格式的支持不如POI强大

POI优点：

效率高

支持公式，宏，一些企业应用上会非常实用

能够修饰单元格属性

支持字体、数字、日期操作

缺点：不成熟,代码不能跨平台，貌似不少同行在使用工程中还碰到让人郁闷的BUG

iint 与Integer 的区别

int是基本数据类型,Integer 是包装类.这里还涉及装箱和拆箱问题,装箱是指把基本数据类型用它们相应的引用类型包装起来,使具有对象的性质.拆箱是将引用类型的对象简化成值类型的数据.

Integer 有两中实例化方法,第一种是new Integer(10),这个是不提倡的,第二种是Integer.valueOf(),这种是比较提倡的,也是默认的.valueof对-128-127之间的值有缓存,如果int值的范围-128-127,在valueof(int)时,它会直接返回IntegerCache的缓存给你.

Integer a=10,Integer b=10 会被翻译成-> Integer a =Integer.valueOf(100);所以a和b得到都是一个Cache对象，并且是同一个！而c和d是新创建的两个不同的对象，所以c自然不等于d。

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

Abstract class 在java中表示的是一种继承关系,一个类只能使用一次继承,但是一个类可以实现多个interface..
在abstract class 可以有自己的数据,也可以有非abstract 的成员方法,而interface中,只能够有静态的不能被修改的数据成员.
Abstract class 表示的是”is-a”关系,interface 表示的是”like-a”关系
抽象类中的变量默认是friendly 型,其值可以在子类中重新定义,也可以重新赋值.

override与overload 的区别

override (重写)

方法名,参数,返回值相同
子类方法不能缩小父类方法的访问权限
子类方法不能抛出比父类方法更多的异常
存在父类和子类之间,
方法被定义为final不能被重写

特点:

覆盖的方法标志必须要和被覆盖的方法标志完全相同,才能达到覆盖的效果
覆盖的方法的返回值必须和被覆盖的方法返回一直
所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者其子类
被覆盖的方法不能为private.

Overload

参数类型,个数,顺序至少有一个不同
不能重载只有返回值不同的方法名
存在父类和子类,同类中.

特点:

(1)在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int)）；

(2)不能通过访问权限、返回类型、抛出的异常进行重载；

(3)方法的异常类型和数目不会对重载造成影响；

Overriding 和overload 是java多态性的不同表现.

拦截器与过滤器的区别

拦截器：是在service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串，也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。

过滤器：是在java web中，你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的 action进行业务逻辑，比如过滤掉非法url,或者在传入servlet或者 struts的action前统一设置字符集，或者去除掉一些非法字符.

区别:

(1)拦截器是基于java的反射机制的，而过滤器是基于函数回调

(2)过滤器依赖与servlet容器，而拦截器不依赖与servlet容器

(3)拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用

(4)拦截器可以访问action上下文、值栈里的对象，而过滤器不能

(5)在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次

Final,finally和finalize的区别

Final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承.

Finally 是异常处理语句结构的一部分,表示总是执行

Finalize 是Object 类的一个方法,在垃圾收集器执行的时候回调用被回收对象的此方法,可以覆盖方法提供垃圾收集时的其他资源回收,例如关闭文件.

5.java的反射机制

开发性和原因连接是反射系统的两大基本要素

6.在java中如何实现多线程

继承Thread 类,覆盖方法run(),我们在创建的Thread类的子类中重写run(),加入线程所要执行的代码.

实现Runnable接口,Runnable 接口只有一个方法run(),我们声明一个类实现Runnable接口并提供这一方法,将我们的线程嗲吗写入其中,就完成了这一部分的任务,但是Runnable接口并没有任何对线程的支持,我们还必须创建Thread类的实例,这一点通过Thread类的构造函数来实现.

Redis的基本数据类型：

String。set。list。hash。sorted set（受特的）

Hibernate/mybatis

什么是MyBatis？

MyBatis 是一个可以自定义SQL、存储过程和高级映射的持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

二.mybatis 与ibatis 的区别

1、Mybatis实现了接口绑定，使用更加方便。

在ibatis2.x中我们需要在DAO的实现类中指定具体对应哪个xml映射文件，

而Mybatis实现了DAO接口与xml映射文件的绑定，自动为我们生成接口的具体实现，使用起来变得更加省事和方便。

这可以说是Mybatis最重要的改进。

2、对象关系映射的改进，效率更高

3、MyBatis采用功能强大的基于OGNL的表达式来消除其他元素。

MyBatis采用OGNL表达式简化了配置文件的复杂性，使用起来更简洁。

Mybatis与hibernate的区别

相同点:Hibernate和Mybatis都是orm对象关系映射框架，都是用于将数据持久化的框架技术。

Hiberante与mybatis都对jdbc进行了封装,但是hibernate较深度的封装了jdbc，对开发者写sql的能力要求的不是那么的高，我们只要通过hql语句操作对象即可完成对数据持久化的操作了。Mybatis封装的没有hibernate那么深，我们可以再配置文件中写sql语句，可以根据需求定制sql语句，数据优化起来较hibernate容易很多。

hibernate可移植性好，需要修改数据库的时候,使用hibernate只需改变一下数据库方言即可搞定。用hibernate框架，数据库的移植变的非常方便。

e它也提供了一些优化策略，比如说懒加载、缓存、策略模式等都是针对于它的优化方案。

Mybatis要求程序员写sql的能力要相对使用hibernate的开发人员要高的多，且可移植性也不是很好。

涉及到大数据的系统使用Mybatis比较好，因为优化较方便。涉及的数据量不是很大且对优化没有那么高，可以使用hibernate

Mybatis 侧重于sql映射,二hibernate侧重于orm

三．基本API

1．SessionFactory

2．Session(save,update,saveOrUpdate,delete,load,get)

3．Query

4．Transaction

四．hibernate.cfg.xml配置文件的加载

使用XML文件进行配置时，可以在配置文件中找到对象类映射文件位置，XML配置文件的位置默认在Classpath下，使用下面的方式来读入XML文件以配置Hibernate：

Configuration config = new Configuration().configure();

默认的XML配置文件名称是hibernate.cfg.xml，您也可以自行指定名称，例如： Configuration config = new Configuration().configure("db.cfg.xml");

五．SessionFactory的创建

Configuration的实例管理Hibernate的配置信息，通常用于建立SessionFactory，例如：SessionFactory sessionFactory = config.buildSessionFactory(); SessionFactory一旦建立，就被赋予Configuration的配置信息，之后改变Configuration 不会影响已建立的 SessionFactory实例，如果对Configuration改变，则要建立一个新的 SessionFactory实例，新的实例中才会包括新的配置信息。

六．主键生成方式

1. increment: 由Hibernate自动以递增的方式生成标识符, 每次递增1

2. identity: 由底层数据库生成标识符. 前提是底层数据库支持自动增长字段类型

3. sequence: Hibernate根据底层数据库的序列生成标识符. 前提是底层数据库支持序列

4. hilo: 适用于代理主键, Hibernate根据hi/low算法生成标识符. Hibernate把特定的字段作为"high".

5. native: 适用于代理主键, 根据底层数据库对自动生成标识符的支持能力, 来选择 identity, sequence, 或hilo

6. uuid.hex: 适用于代理主键, Hibernate采用128位的UUID(Universal Identification)算法生成标识符.

7. assigned: 适用于自然主键, 由Java应用程序生成标识符.为了能让Java应用程序设置OID,不要把方法声明为private类型.应当尽量避免使用自然主键.

七． get()、load()的区别

(1) get()执行时会立即发送sql语句，查询结果，查询后session关闭没有影响，load()执行时不会立即发送sql语句，在使用返回结果的时候才查询，如果session关闭，就会出现惰性加载异常；

(2)get()查询时,如果所传的id没有对应的记录，直接返回null，不会报错，而load()查询时，若果没有对应的id会出现org..hibernate.ObjectNotFoundException

3） load()可返回实体的代理类实例，get()直接返回实体

4） load()可在一、二级缓存查找数据，get()只在一级缓存找，若无则直接调用SQL语句在数据库中找

八．关于query查询

Query.list()若果没有记录也不是null，而是空集合get(0)的时候会出现越界异常。 Query.uniqueResult()有一条记录的时候用此方法。

九．事务

Hibernate事务默认不自动提交，这种不自动提交是在获得session的时候设置的。而session.beginTransaction()是对session中事务的设置做检查。

十．类到表的映射的两种方法

1. 在配置文件中配置hbm2ddl.auto属性，其值有以下四种：create，validate，update， create-drop，然后在编写加载配置文件的类

注意:

create：

每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。

create-drop ：

每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。

update：

最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。

validate ：

每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。

2. 用类来完成 Configration config = new Configration（）.configue(); SchemaExport export = new SchemaExport(config); Export.create(true,true);

十一．实体对象的生命周期

1. transient（临时状态）实体对象在内存中存在，与数据库中的记录无关，不受session 管理，对对象的修改不会影响数据库。

2. persisent（持久状态）与表记录相关联，受session管理，对对象的修改，在事务提交或session关闭前会执行update操作。

3. detached（游离状态）有表记录关联，不受session管理。各个状态间的转换：

十二．缓存

(1) Session缓存，实例状态及生命周期由session缓存生命周期决定，Session生命周期存在，持久化对象缓存在session中，session消亡，缓存的持久化对象也就消亡。

(2)不同的session，缓存存储的对象也不同。

(3) Session缓存持久化实例对象，不持久化实例的某些属性

(4) 一级session缓存可以将查询到的持久化实体对象缓存到session中，而普通的查询实体的某属性时，不会在session中缓存。下面方法将实体对象放入Session缓存中：load() get() save() iterate() 在session范围缓存的对象，当session执行clear()或evict(Object o)方法后，缓存就会清除所有或某个持久化对象，这样session缓存就被清理。 session.flush(); session.clear();

(5) 二级缓存：进程缓存，一个数据库对应一个SessionFactory。二级缓存由SessionFactory来理。二级缓存可以通过配置SessionFactory来配置打开与关闭。 <property name="cache.use_second_level_cache">false</property> 二级缓存需要第三方插件来设置

十三hibernate的优缺点

优点：1、程序更加面向对象；

2、提高了生产率；

3、方便移植（修改配置文件）；

4、无侵入性。

缺点：

1、效率比JDBC略差；

2、不适合批量操作。

3、只能配置一种关联关系

十四. hibernate的工作原理

1.配置好hibernate的配置文件和与类对应的配置文件后，启动服务器

2.服务器通过实例化Configuration对象，读取hibernate.cfg.xml文件的配置内容，并根据相关的需求建好表或者和表建立好映射关系

3.通过实例化的Configuration对象就可以建立sessionFactory实例，进一步，通过sessionFactory实例可以创建 session对象

4.得到session之后，便可以对数据库进行增删改查操作了，除了比较复杂的全文搜索外，简单的操作都可以通过hibernate封装好的 session内置方法来实现

5.此外，还可以通过事物管理，表的关联来实现较为复杂的数据库设计

十五.Hibernate的二级缓存策略

　　1) 条件查询的时候，总是发出一条select * from table_name where …. （选择所有字段）这样的SQL语句查询数据库，一次获得所有的数据对象。

　　2) 把获得的所有数据对象根据ID放入到第二级缓存中。

　　3) 当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；查不到，再查询数据库，把结果按照ID放入到缓存。

4) 删除、更新、增加数据的时候，同时更新缓存。

缓存的范围:

1). 事务范围：缓存只能被当前事务访问；缓存的生命周期依赖于事务的生命周期；缓存的介质是内存。

2). 进程范围：缓存被进程内的所以事务共享；缓存的生命周期依赖于进程的生命周期；缓存的介质是内存或者硬盘。

3). 集群范围：在集群环境中缓存被一个计算机或者多个计算机共享。

事务范围的缓存是持久化层的第一级缓存，通常是必须的；进程范围或集群范围的缓存是持久化层的第二级缓存，通常可选。进程范围或集群范围的缓存会出现并发问题，可采用4中并发访问策略，每种策略对应一种事务级别：

1. 事务型：仅在受管理环境中适用。提供“可重复读”事务隔离级别。（高）

2. 读写型：仅在非集群的环境中适用。提供“已提交读”事务隔离级别。

3. 非严格读写型：不保证缓存与数据库中数据的一致性。极少改，允许偶尔脏读

4. 只读型：从不修改的数据。（最低）隔离级别越高，并发性能就越低

十六. Hibernate 的初始化.

1)创建Configeration类的实例。

它的构造方法：将配置信息(Hibernate config.xml)读入到内存。

一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。

2)创建SessionFactory实例

把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。

SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。

3)调用SessionFactory创建Session的方法

十七. 状态转换

临时状态 (transient)

1】不处于Session 缓存中

2】数据库中没有对象记录

Java如何进入临时状态

1】通过new语句刚创建一个对象时

2】当调用Session 的delete()方法，从Session 缓存中删除一个对象时。

持久化状态(persisted)

1】处于Session 缓存中

2】持久化对象数据库中有对象记录

3】Session 在特定时刻会保持二者同步

Java如何进入持久化状态

1】Session 的save()把临时－》持久化状态

2】Session 的load(),get()方法返回的对象

3】Session 的find()返回的list集合中存放的对象

4】Session 的update(),saveOrupdate()使游离－》持久化

游离状态(detached)

1】不再位于Session 缓存中

2】游离对象由持久化状态转变而来，数据库中可能还有对应记录。

Java如何进入持久化状态－》游离状态

1】Session 的close()方法

2】Session 的evict()方法，从缓存中删除一个对象。提高性能。少用。

十八. Hibernate设置事务隔离级别

1. 读操作未提交(Read Uncommited)：允许脏读取，不允许更新丢失，该隔离级别可以通过“排他写锁”实现；1

2. 读操作已提交(Read Commited)：允许不可重复读取，不允许脏读取2

3. 可重复读(Repeatable Read)：禁止不可重复读和脏读取，但有时可能出现幻像数据；4

4. 可串行化(Serializable)：提供严格的事务隔离。8

在hibernate.cfg.xml中配置隔离级别： <session-factory> <propertyname=”hibernate.connection_isolation”>4</property> </session-factory>

十九. 乐观锁，悲观锁

在org.hibernate包下有一个名为LockMode的类：包含了主要锁定模式：

1). LockMode.None

2). LockMode.Read

3). LockMode.UPGRADE:

当数据库支持悲观锁，就执行select…for update,反之普通select

4). LockMode.UPGRADE_NOWAIT：对oracle执行select for update nowait语句 5).LockMode.WRITE：当Hibernate向数据库保存或者更新一个对象时，会自动使用

此模式。

6).LockMode.FORCE：对于使用了version的记录会强制增加version的值

悲观锁：

Hibernate中主要通过显式地设定锁定模式来设置悲观锁定。

有以下几种方式：

1). 调用Session.load()指定锁定模式；

2). 调用Session.lock()可以为对象设定锁定模式；

3). 调用Query.setLockMode()可以设定查询语句获取对象的锁定。

乐观锁：

主要由Hibernate提供的版本控制功能来实现乐观锁定。

<version>:利用一个递增的整数来根据数据库表中记录的版本。 <timestamp>:用时间戳来跟踪数据库表中记录的版本

二十.N+1查询问题

当你查询时首先hibernate会发出一天查询所有主键的sql语句，然后跟新缓存。N就是指首先hiberante会到缓存中查询，如果缓存中不存在与之匹配的数据，再会发出sql查询。

主要的原因是：默认情况下iterate利用缓存数据来查询，当缓存为空会多查询一次，把ID加进来。

解决方案:

Hibernate:

设置fetch=FetchType.LAZY,这种方法在合适的时候（具体使用到对象时）还是会发出select语句。
用session.createCriteria()做查询
使用join fetch做外连接查询。

Mybatis:

使用一条SQL语句,主外键相关表的信息全部查询处理
使用MyBatis的延迟加载机制. MyBatis的延迟加载机制需要使用cglib包，因此应向工程中添加此包,在配置文件中配置: <settingname="lazyLoadingEnabled"value="true"/>

<settingname="aggressiveLazyLoading"value="false"/>

二十一.mybatis 中SQL映射

SQL映射实现

1、在包com/xunpoit/pojo下创建User类，包含相关属性定义

2、新建SQL映射文件com/xunpoit/pojo/User.xml，文件中包含SQL代码和映射定义信息，与User类同包

<select id="selectUser" parameterType="int“ resultType="com.xunpoit.pojo.User"> select * from t_user where id = #{id} </select>

<select id="selectAllUser" resultType="com.xunpoit.pojo.User"> select * from t_user </select>

<insert id="addUser" parameterType="com.xunpoit.pojo.User"> insert into t_user(id,username,password,addr) values(#{id},#{userName},#{password},#{addr}) </insert> </mapper>

3. SQL 映射XML 文件仅仅只有一些初级的元素：

cache – 配置给定模式的缓存

cache-ref – 从别的模式中引用一个缓存

resultMap – 这是最复杂而却强大的一个元素了，它描述如何从结果集中加载对象

sql – 一个可以被其他语句复用的SQL 块 insert – 映射INSERT 语句 update – 映射UPDATE 语句 delete – 映射DELEETE 语句 select – 映射SELECT 语句

二十二.mybatis中# 与$的区别

1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。　　

2. $将传入的数据直接显示生成在sql中。　　

3. #方式能够很大程度防止sql注入。$方式无法防止Sql注入。

4.$方式一般用于传入数据库对象，例如传入表名.　　

5.一般能用#的就别用$.

6.MyBatis排序时使用order by 动态参数时需要注意，用$而不是#

一. Spring特点

◆方便解耦，简化开发

通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

◆AOP编程的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

◆声明式事务的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

◆方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。

◆方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

◆降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

二.spring框架

组成Spring框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

1、核心容器(Core)：核心容器提供 Spring 框架的基本功能(Spring Core)。核心容器的主要组件是BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

2、Spring 上下文：Spring 上下文是一个配置文件，向 Spring框架提供上下文信息。Spring 上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。

3、Spring AOP：通过配置管理特性，Spring AOP模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持AOP。Spring AOP模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖EJB组件，就可以将声明性事务管理集成到应用程序中。

4、Spring DAO：JDBCDAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向JDBC的异常遵从通用的 DAO 异常层次结构。

5、Spring ORM：Spring 框架插入了若干个ORM框架，从而提供了ORM的对象关系工具，其中包括JDO、Hibernate和iBatisSQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

6、Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

7、Spring MVC框架：MVC框架是一个全功能的构建 Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的，MVC容纳了大量视图技术，其中包括JSP、Velocity、Tiles、iText和 POI。模型由javabean构成，存放于Map；视图是一个接口，负责显示模型；控制器表示逻辑代码，是Controller的实现。Spring框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE 环境（Web 或EJB）、独立应用程序、测试环境之间重用。

三.声明式事务

声明式事物管理意味着你无需在Bean中编写任何事物管理代码，只需将事物配置在Bean上就可以了。想要到达这个目的，最简单的方法就是使用代理——代理会拦截所有的方法的调用。如果方法名位于事物配置中，代理就是起到通知(around)的作用。它会在目标方法调用前开启事物，然后在一个try/catch块执行目标方法。如果目标方法正常完成，代理就会提交事物；如果目标抛出运行时异常，代理就会进行回滚。为了完成这些事情，代理需要配置好PlatfromTransactionManager。这是声明式事务管理的核心概念，其独特指出就是创建代理的方式不同。

事务的传播特性

1. PROPAGATION_REQUIRED(required): 如果存在一个事务，则支持当前事务。如果没有事务则开启（常用的配置）

2. PROPAGATION_SUPPORTS(supports): 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行

3. PROPAGATION_MANDATORY(mandatory): 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

4. PROPAGATION_REQUIRES_NEW(requires_new): 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

5. PROPAGATION_NOT_SUPPORTED(not_supported): 总是非事务地执行，并挂起任何存在的事务。

6. PROPAGATION_NEVER(never): 总是非事务地执行，如果存在一个活动事务，则抛出异常

Spring配置声明式事务：

* 配置SessionFactory

* 配置事务管理器

* 事务的传播特性

* 那些类那些方法使用事务

具体配置如下:

<value>classpath:hibernate.cfg.xml</value>

</property>

</bean>

</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="add*" propagation="REQUIRED"/>

<tx:method name="del*" propagation="REQUIRED"/>

<tx:method name="modify*" propagation="REQUIRED"/>

<tx:method name="*" propagation="REQUIRED" read-only="true"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression="execution(* com.biped.service.*.*(..))" id="transactionPC"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPC"/>

</aop:config>

</bean>

</bean>

四.事务配置方式:

第一种:每个bean一个代理

第二种方式：所有Bean共享一个代理基类

第三种方式：使用拦截器

第四种方式：使用tx标签配置的拦截器

第五种方式：全注解

五.事务管理方式

1.annotation(注解)

2.xml配置(aop技术)

<bean id="txManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

<tx:annotation-driven transaction-manager="txManager" />

<!-- 2.xml方式配置事务.利用aop技术

<aop:config>

<aop:pointcut id="transactionPointcut" expression="execution(* com.test.service..*.*(..))"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>

</aop:config>

<tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes>

<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>

<tx:method name="*"/>

</tx:attributes>

</tx:advice>

-->

六.注入方式

1.通过setter方式

2.构造方式

3.注解方式

@Resource

@Autowired

两者的区别：1. @Resource标注是由JDK提供的，而@Autowired标注是由Spring提供的，因而@Autowired标注会与Spring紧密耦合，所以推荐使用@Resource标注；

2. @Resource默认是按照名称来装配注入的，当找不到与名称匹配的bean才会按照类型来装配注入；

3. @Autowired默认是按照类型装配注入的，假如想按照名称来转配注入，则需要结合@Qualifier一起使用；

4. @Resource和@Autowired都可以用来标注字段或者setter方法。

七. 什么是Spring

------开源的，控制反转（Inversion of Control）和面向切面的容器框架。

Spring核心：

IOC（控制反转）-------创建对象并且组装对象之间的关系。

IOC:应用程序本身不负责依赖对象的创建和维护，依赖对象的创建和维护是由外部容器负责的。这样控制权就由应用程序转移到了外部容器。控制权的转移就是所谓的反转。

依赖注入：Dependency Injection：在运行时由外部容器将依赖对象注入到组件中。

八. 为什么使用Spring

1：降低组件之间的耦合度，实现各层之间的解耦

2：可以使用容器提供的众多服务。如：

--事务管理服务

--JMS

--Spring core核心服务

--持久化服务

--其他

3：提供了单例模式支持。开发人员不需要自己编写实现代码

4：提供了AOP技术。实现如：权限拦截，运行监控等功能

5：提供了众多的辅助类。如JDBC Template，HIbernate Template

6：对主流的应用框架提供了集成支持。集成Struts，JPA，Hibernate

九. spring的7个模块

spring核心容器(Core)

spring上下文

springAOP

SpringDAO

SpringORM

springWeb支持struts集成

springMVC自带的mvc框架

十. spring实现的2种设计模式

单列模式：接受容器管理的bean，默认采用单态模式管理。

工厂模式：spring就是实例化和管理全部bean的工厂。spring的上下文也就是工厂，也被设计成单态的

十一. Spring实例化bean的三种方式

1：默认使用类加载器

2：使用静态工厂方法实例化bean对象

3：使用实例工厂方法实例化bena对象

十二. Bean的作用域

Singleton

Spring容器只存在一个共享的bean实例，默认的配置。

Prototype

每次对bean的请求都会创建一个新的bean实例。

两者如何选择？原则：所有有状态的bean都使用Prototype作用域，而对无状态的bean则应该使用singleton作用域。

十三. Spring的生命周期

bean的实例化：

1：当作用域范围为singleton时，在初始化Spring容易的时候实例化bean实例。

---1：如果lazy-init的值为true，则为延迟bean的实例化，即在Spring容器启动时不实例化bean的对象

2：当作用域范围为prototype时，在调用Spring的getBean的方法时实例化bean对象

注入依赖对象可以采用手工装配或者自动装配，在实际应用中建议采用手工装配。因为自动装配会产生未知情况，开发人员无法预见最终的装配结果。

十四.AOP中的概念

Aspect： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

　　Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

　　Pointcut（切入点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

Advice（通知）：Advice 定义了在 pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

Weaving（织入）:织入，指将通知插入到目标对象。

Target（目标对象）:目标对象，指需要织入切面的对象。

Proxy（代理对象）:代理对象，指切面织入目标对象之后形成的对象。

十五.spring AOP 动态代理的过程

(1) 将切面使用动态代理的方式动态织入到目标对象（被代理类），形成一个代理对象；

(2) 目标对象如果没有实现代理接口，那么Spring会采用CGLib来生成代理对象，该代理对象是目标对象的子类；

(3) 目标对象如果是final类，并且也没实现代理接口，就不能运用AOP。

十六. 配置过程：

（1）配置目标对象

（2）配置通知

（3）利用ProxyFactoryBean将通知织入到目标对象，形成一个动态代理对象

（4）客户端使用动态代理来访问目标对象的方法。

十七. 关于Spring与EJB

Spring与EJB3.0之间的关系是竞争关系。

① Spring是一个开源的框架，而EJB3.0是一个标准（标准意味着将得到广泛的支持以及良好的兼容性），并且，采用EJB3.0，项目的后期维护得到了保证。

② Spring是一个轻量级框架，EJB3.0是一个重量级框架（完整的容器，包含所有的服务）。

③ Spring的IoC，AOP集成了大量的开源框架，可扩展性良好。EJB3.0的可扩展性则完全依赖于新的容器。

④ Spring对事务支持不如EJB3.0成熟，Spring对集群的兼容也不够。

⑤ Spring与EJB3.0都是一个企业级开发框架，都支持声明式事务。

十八.springMVC常用注解:

@Controller 负责注册一个bean 到spring 上下文中，bean 的ID 默认为类名称开头字母小写,你也可以自己指定

@RequestMapping用来定义访问的URL，你可以为整个类/方法定义一个

@RequestBody 将HTTP请求正文转换为适合的HttpMessageConverter对象。

@ResponseBody 将内容或对象作为 HTTP 响应正文返回，并调用适合HttpMessageConverter的Adapter转换对象，写入输出流。

@CookieValue 获取cookie信息

@RequestHeader 获取请求的头部信息

十九.什么springbatch

Spring Batch是一个轻量级的，完全面向Spring的批处理框架，可以应用于企业级大量的数据处理系统。Spring Batch以POJO和大家熟知的Spring框架为基础，使开发者更容易的访问和利用企业级服务。Spring Batch可以提供大量的，可重复的数据处理功能，包括日志记录/跟踪，事务管理，作业处理统计工作重新启动、跳过，和资源管理等重要功能。

二十.springbatch的执行流程

每个Batch都会包含一个Job。Job就像一个容器，这个容器里装了若干Step，Batch中实际干活的也就是这些Step，Step主要是读取数据，处理数据，然后将这些数据存储起来(ItemReader用来读取数据，ItemProcessor用来处理数据，ItemWriter用来写数据) 。JobLauncher用来启动Job，JobRepository是上述处理提供的一种持久化机制，它为JobLauncher，Job，和Step实例提供CRUD操作。

外部控制器调用JobLauncher启动一个Job，Job调用自己的Step去实现对数据的操作，Step处理完成后，再将处理结果一步步返回给上一层，这就是Batch处理实现的一个简单流程。

Struts:

一.

Rest

什么是rest

REST是REpresentational State Transfer的缩写（一般中文翻译为表述性状态转移）。一种体系结构。而HTTP是一种包含了REST架构属性的协议。在REST中所有东西都被看作资源。每一个资源都有一个URI和它对应。每个REST请求都是孤立的，请求中包含了所需的全部信息。REST服务端不存储状态。REST支持不同的通信数据格式，比如XML、JSON。

rest 的原则

URL表示资源

HTTP方法表示操作

GET只是用来请求操作，GET操作永远都不应该修改服务器的状态。

服务应该是无状态的

WebService

一.什么是webservice

是一个SOA的架构,它是不依赖与语言,不依赖于平台,可以实现不同的语言见的相互调用,通过Internet 进行基于http协议的网络应用间的交互.

WebService 实现不同语言间的调用,是依托于一个标准,webservice是需要遵守WSDL/SOAP 规范的.通过标准的协议和接口,可以让不同的程序集成的一种SOA架构.

二.webservice的优点

1.跨平台的程序相互访问

2.松耦合

3.基于标准协议

三.WebService的基本原理

1.Service provider 采用WSDL 描述服务

2.Service Provider 采用UUDI将服务的描述文件发布到UDDI服务器

3. Service Requestor在UDDI服务器上查询并获取WSDL文件

4. Service Requestor将请求绑定到SOAP，并访问相应的服务。

四.webservice 名词解释

JAXP(Java API for XML Parsing) 定义了在Java中使用DOM, SAX, XSLT的通用的接口。这样在你的程序中你只要使用这些通用的接口，当你需要改变具体的实现时候也不需要修改代码。

　　JAXM(Java API for XML Messaging) 是为SOAP通信提供访问方法和传输机制的API。

　　WSDL(Web Services Description Language)是一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点（服务）。

　　SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。

　　UDDI (Universal Description, Discovery, and Integration) 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

在用户能够调用Web服务之前，必须确定这个服务内包含哪些商务方法，找到被调用的接口定义，还要在服务端来编制软件，UDDI是一种根据描述文档来引导系统查找相应服务的机制。UDDI利用SOAP消息机制（标准的XML/HTTP）来发布，编辑，浏览以及查找注册信息。它采用XML格式来封装各种不同类型的数据，并且发送到注册中心或者由注册中心来返回需要的数据。

五.什么是SOA

面向服务的架构（Service Oriented Architecture，SOA）是表示所谓服务的自包含功能单元的一种软件设计原则和架构设计模式。SOA推崇松耦合、复用性和粗粒度的服务设计原则。在企业架构方面，SOA带来的好处包括对业务需求的敏捷交付和迅速反应，通过降低集成成本提高投资回报率，通过复用组件降低开放成本。企业架构一般使用企业服务总线(ESB)作为大型企业线上应用的集成层

六. 应用集成方式有哪些

1. 共享数据库

2. 批量文件传输

3. 远程过程调用（RPC）

4. 通过消息中间件来交换异步信息（MOM）

七. 应用集成可以采用的Web服务方式有什么？

SOAP WS（Simple Object Access Protocal）和RESTful Web Service（REpresentational State Transfer）

八. SOAP WS 和RESTful Web Service之间有什么不同呢？

1.SOAP WS支持既远程过程调用（例如，RPC）又支持消息中间件（MOM）方式进行应用集成。而Restful Web Service仅支持RPC集成方式。

2.SOAP WS是传输协议无关的。它支持多种协议，比如，HTTP(S)、 Messaging、TCP、UDP SMTP等等。而REST是协议相关的，只支持HTTP或者HTTPS协议。

3.SOAP WS仅允许使用XML数据格式。定义的操作通过POST请求发送。其重点是通过操作名来获取服务，并将应用逻辑封装为服务。而REST方式则允许多种数据格式，而且由于REST方式采用标准GET、PUT、PSOT和DELETE 方法，因此所有的浏览器都可以支持。其重点是通过资源名来获取服务，并将数据封装为服务。AJAX支持REST方式，它可以使用XMLHttpRequest对象。无状态CRUD操作（创建、读、更新和删除）更加适合这种方式。

九. SOA和Web service的区别是什么？

SOA是一种软件设计准则，一种实现松耦合，高可复用性和粗粒度的web服务的设计模式。开发者可以选择任意协议实现SOA，例如，HTTP、HTTPS、JMS、SMTP、RMI、IIOP（例如，采用IIOP的EJB）、RPC等。消息可以采用XML或者数据传输对象（Data Transfer Objects，DTOs）。

Web Service是实现SOA的技术之一。也可以不用Web service来实现SOA应用：例如，用一些传统的技术，像Java RMI，EJB，JMS消息等。但是Web service提供的是标准的平台无关的服务，这些服务采用HTTP、XML、SOAP、WSDL和UDDI技术，因此可以带来J2EE和.NET这些异构技术（heterogeneous technologies）之间的互操作性。

十. 如果可以使用传统的中间件方式，例如，RPC、CORBA、RMI和DCOM，为什么还要选择Web service？

传统的中间件跟应用关系紧密，对应用的任何修改都可能会引起对应中间件的修改。因此这种方式下应用不好维护，复用性也比较差。一般情况下也无法支持异质系统（heterogeneity）。另外，采用这种方式应尽量避免互联网访问应用。还有，这种方式代价更高并且可用性差。

Web service采用松耦合连接，即在客户端和服务器端之间提供了一个抽象层。这种松耦合应用可以减少维护成本并增加可复用性。Web service提供了一种基于XML和Web的新的中间件形式。Web service是语言和平台无关的，任何语言都可以用来开发一个Web service，并且部署到任何平台上，包括小型设备到大型超级计算机。Web service采用语言无关协议，例如HTTP，并且通过Web API来在不同的应用程序之间传输XML消息。Web service可以通过互联网访问，开销少并且可用性好。

十一. 开发基于SOAP的Web service有哪些方式呢？

契约先行（也称为自顶向下，contract-first）方式：通过XSD和WSDL来定义contract，然后根据contract生成Java类；

契约后行（也称为自底向上，contract-last）方式：先定义Java类，然后生成约定，也就是从Java类得到WSDL文件。

Dubbo+zookeeper

dubbo的出现是为了解决什么问题

当服务越来越多时，服务URL配置管理变得非常困难，F5硬件负载均衡器的单点压力也越来越大。
当进一步发展，服务间依赖关系变得错踪复杂，甚至分不清哪个应用要在哪个应用之前启动，架构师都不能完整的描述应用的架构关系
接着，服务的调用量越来越大，服务的容量问题就暴露出来，这个服务需要多少机器支撑？什么时候该加机器？

dubbo 是什么

Dubbo是一个分布式服务框架，以及SOA治理方案。其功能主要包括：高性能NIO通讯及多协议集成，服务动态寻址与路由，软负载均衡与容错，依赖分析与降级等。

Zookeeper是如何完成注册的

保存了服务提供方和服务消费方的的URI（dubbo自定义的一种URI），服务消费方找到zookeeper，向zookeeper要到服务提供方的URI，然后就找到提供方，并调用提供方的服务。

Dubbo 在安全机制方面是如何解决的

Dubbo主要针对内部服务，对外的服务，阿里有开放平台来处理安全和流控，所以Dubbo在安全方面实现的功能较少，基本上只防君子不防小人，只防止误调用。Dubbo通过Token令牌防止用户绕过注册中心直连，然后在注册中心上管理授权。Dubbo还提供服务黑白名单，来控制服务所允许的调用方。

dubbo的工作原理

节点角色说明：

Provider: 暴露服务的服务提供方。

Consumer: 调用远程服务的服务消费方。

Registry: 服务注册与发现的注册中心。

Monitor: 统计服务的调用次调和调用时间的监控中心。

Container: 服务运行容器。

工作原理:

服务运行容器启动,加载,运行服务提供者,在服务提供者启动适合,就向注册中心注册自己提供的服务,服务消费者在启动的时候,向注册中心订阅自己所需要的服务.注册中心返回服务提供者地址给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者.消费者从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用.服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据懂啊监控中心.

支付系统开发

支付平台：往小说就是个中间件，可以帮助你转发各种付款，收款，查询的要求。但是做大了就是公司的资金出入口，负责公司和银行之间资金流向的桥梁，随着时代发展，电子商务飞速发展，第三方支付也是层出不穷，可以说几乎每个时刻都在突出新的支付类型，各个银行推出网上支付，代扣，代收付，这种便利的交易方式，使得我们可以不出门就可以东西，但是随这支付方式的增加，电子商务公司就需要把所有支付方式放在一个系统进行统一管理，这就是支付平台，我个人理解支付平台最大的功能，有效的系统的管理公司所有的资金流向，确保资金交易不会出错。即便出错才可以自我补救。

支付平台需要注意哪些?

1.入口统一。而且不应经常变化，无论收款，付款，查询，对账都应是一个入口（这也是我做了几种类型后才发现的。）入口统一的好处，集成方便，客户群只需要知道接口和参数便可方便集成

2.支付渠道可以来回切换。支付平台的支付功能接口可以固定，譬如（支付，代扣，转账）可以固定，但是选取那个银行接口应是可以切换的，这就需要将支付方式活配，客户可以指定那个银行进行支付，也可以不指定，我们根据客户的要求自动分配合理方案。

3.支付数据存储方式应统一化。刚开始做的时候为每一个支付渠道，后来出现数据表泛滥，这也是弯路所有的支付渠道都有共同点，所以在数据库设计这里应该谨慎，必先出现表泛滥，应当将渠道统一化，个别的可以采用扩展表方式

4.为客户提供补充处理。有些银行在支付过程中无法提供明确的结果回应，这就需要采用延时查询结果功能，大多采用定时处理进行。

5.业务主流程要清晰。不应随意改变，建议采用控制反转。

6.对于重复支付的控制。除了网上银行的方式我们无法控制，但是实时类支付应当做到尽量控制重复支付的情况

商户网站接入支付结果有几种方式

有两种方式,分别是通过浏览器进行跳转通知 ,通过服务器异步通知

浏览器跳转通知：这种方式主要是基于用户访问的浏览器，如果用户在银行页面支付成功后，直接关闭了页面，并未等待银行跳转到支付结果页面，那么商户网站就收不到支付结果的通知，导致支付结果难以处理。而且浏览器端数据很容易被篡改，而降低安全性。所以我们推荐技术人员开发时使用后端服务器通知做技术判断，而只将前台通知进行支付相关显示，不进行逻辑处理。

服务器异步通知：该方式是支付公司服务器后台直接向用户指定的异步通知URL发送参数，采用POST或GET的方式。商户网站接收异部参数的URL对应的程序中，要对支付公司返回的支付结果进行签名验证，成功后进行支付逻辑处理，如验证金额、订单信息是否与发起支付时一致，验证正常则对订单进行状态处理或为用户进行网站内入账等。

现在支付公司提供的结算周期模式

T+0 和T+1 模式

T+1模式时，即用户支付完毕后，支付公司将在第二天进行结算，商户即可将资金提取到自己的银行卡，或支付公司直接结算到约定的商户收款账户中。

T+0的模式，则支付资金可以随时清算，并提现到商户银行卡。

收款流程

商户网站将支付信息提供给支付网关后，网站引导用户进入相关银行网关进行支付，完成后银行扣款，并将支付结果返回给第三方支付公司，支付公司收到结果后将为商户进行支付平台内的入账处理，等待结算。结算完成后，商户即可登录第三方支付平台进行提现，将资金通过第三方支付平台转入到自己的银行卡中。

开发流程

与支付公司签约后，网站将获得相关开商户号、密钥、支付网关以及开发文档。技术人员通过阅读文档，获取需要使用的相关数据参数，如商品名称、金额等，并通过约定的加密方式及密钥进行加密处理，将以FORM表单POST或GET的方式发送给支付公司提供的支付网关URL。

支付网关收到商户提供的相关参数后将进行数据处理及加密验证，如果数据合格且密钥验证成功，将引导用户进入各家银行选择页面，用户在选择自己使用的银行后，将进入相关银行的支付网关进行支付。

用户在银行网关成功付款后，银行进行扣款，并将支付结果回传给支付公司，支付公司收到银行的结果，同样进行签名验证，并将支付结果信息传递给商户网站。

支付公司将支付结果传递给商户网站也是通过FORM表单的方式，只是该数据传递属于服务器后端处理的。商户网站向支付公司发起支付请求传递支付相关参数时，就包含一个或两个URL，用于指定接收支付结果的URL中。

有几种接入方案

两种接入方案.

直接与银行对接与通过中间公司间接与银行对接

直接与银行对接

优缺点:

因为直接与银行进行财务结算,交易资金结算比较安全,适合资金流量比较大的企业,这种方案适合于:每月结算金额百万以上的企业.

缺点:开发工作量比较大,而且银行会不定期升级系统交易系统,随着银行系统的升级,企业也需要做相应改动,所以维护工作量比较大,而且企业每年还需要向银行交纳一定数量的接口使用费.

通过中间公司与银行对接

优点:

开发工作量少,因为使用的是中间企业提供的接入规范,所以银行升级系统,不需要企业做相应修改,除非中间企业的接入规范发生了改变,企业才作相应修改.相对前一种接入方案,这种方案的维护工作量比较少,因为只与一家企业对接,所以接入费用相对比较低,这种方案适合于:每个月结算金额在几十万以下的中小企业.

缺点:因为是与中间企业进行资金结算,目前所有中间企业都是私企,资金安全是一个大问题.

中间支付公司有哪些

首信易支付

每年需要交纳一定的接口费用,并且从交易金额中扣除1%的手续费,当当网,红孩儿,京东商城使用了首信易支付

易宝支付

接入免费,只从交易金额中扣除1%的手续费.例如E网往,巴巴运动网

易宝支付接入规范

MD5-hmac

Hmac 是一种秘密的密钥验证算法.Hmac 提供的数据完整性和源省份验证完全取决于密钥分配范恩,如果只有发起者和接收者知道Hmac 密钥.这么就对两者间发送的数据提供了源身份验证和完整性保证.

StringBUffer sValue = new StringBuffer();

sValue.append(“tanghuan”);

sValue.appernd(“012345”);

String hmacMD5 = DigestUtil.hmacSign(sValue.toString(),”123456”);

易宝的支付流程

通过http请求方式像易宝支付网关发起一个支付请求,就是向https://www.yeepay/.com/app-merchat-proxy/node 发起请求,请求可以是get或post方式提交,页面采用GBK/GB2312编码.

易宝支付网关对企业发来的数据使用用户的密钥生成MD5-hmac码,然后跟企业发来的MD5-hmac码比较是否相同,如果相同即把请求转发到银行网关,当用户支付完成后,银行网关会引导用户的浏览器重定向到易宝支付网关,然后易宝支付网关再引导用户的浏览器重定向到企业提供的url

给易宝支付网关发送的数据

业务类型,商户编号,商户订单号,支付金额,交易币种,商户接收支付成功数据的地址,商户扩展信息,银行编码,应答机制(0—200状态成功;1—返回success字符串),商品名称,商品种类,商品描述,送货地址(后四个可选)

十一.使用易宝支付常见问题

问题一：

请求查询绑卡信息的时候，报{"error_code":"600000","error_msg":"illegal request"}

解决方案：

与易宝沟通，易宝说我们的测试服务器的ip必须在易宝那边报备，才不会出现这个问题。

问题二：

在本地环境中，前台回调地址可以接收到，但是后台异步通知地址始终接受不到？

解决方案:

后台异步通知地址必须是外网可以访问的，所以必须在测试服务器上面进行，才能接收到。

十二.支付接口中的异步通知和同步通知的区别

1 异步通知和同步通知都需要有回调地址，如果没有回调地址，易宝支付平台是没有任何回调的。

2 异步通知和同步通知，如果是易宝支付平台自动回调的话，那么回调地址必须能够公网访问。

3 同步通知：商户服务器发起请求，易宝支付平台处理完成之后，通过浏览器跳转的方式，通知我们交易完成或者失败。

异步通知：商户服务器发起请求，易宝支付平台处理完成后，不以浏览器跳转的方式通知商户，而是服务器与服务器之间通信，将处理的结果通过我们的异步回调地址通知我们，这时候我们会按照事先和易宝平台协定的方式回应易宝支付，如果没有回应易宝支付会隔断时间再以服务器与服务器之间通信的方式，通知我，我只有按照商定的方式返回给他才行。

十三. 很多时候我们登陆需要验证码，一个用户对应一个验证码，1000万个用户对应1000万个验证码，那么如何知道这个验证码是这个用户，那个验证码是那个用户的呢？

解决方案：

其实每生成一个验证码，会生成seesion存储，这时候会在浏览器生成一个cookie来存储seesionid，这个sessionid可以帮助服务器找到合适的session文件。

Nginx

一. 什么是Nginx

Nginx 是一个非常优秀的HTTP服务器,由于其并发能力强,并且体积很小,所以被称为轻量级http服务软件.nginx 不单可以作为强大的web服务器,还可以作为一个反向代理服务器.而且nginx还可以按照调度规则实现动态、静态页面的分离，可以按照轮询、ip哈希、URL哈希、权重等多种方式对后端服务器做负载均衡，同时还支持后端服务器的健康检查。

二.如何配置负载均衡

在http节点里添加:

#定义负载均衡设备的 Ip及设备状态

upstream myServer {

server 127.0.0.1:9090 down;

server 127.0.0.1:8080 weight=2;

server 127.0.0.1:6060;

server 127.0.0.1:7070 backup;

}

在需要使用负载的Server节点下添加

proxy_pass http://myServer;

upstream 每个设备的状态:

down 表示单前的server暂时不参与负载

weight 默认为1.weight越大，负载的权重就越大。

max_fails ：允许请求失败的次数默认为1.当超过最大次数时，返回proxy_next_upstream 模块定义的错误

fail_timeout:max_fails 次失败后，暂停的时间。

backup：其它所有的非backup机器down或者忙的时候，请求backup机器。所以这台机器压力会最轻。

使用nginx常出现什么问题

session不同享,登陆状态不一致

如何实现多台服务器之间的session共享

1、不使用session，换用cookie

session是存放在服务器端的，cookie是存放在客户端的，我们可以把用户访问页面产生的session放到cookie里面，就是以cookie为中转站。你访问web服务器A，产生了session然后把它放到cookie里面，当你的请求被分配到B服务器时，服务器B先判断服务器有没有这个session，如果没有，再去看看客户端的cookie里面有没有这个session，如果也没有，说明session真的不存，如果cookie里面有，就把cookie里面的sessoin同步到服务器B，这样就可以实现session的同步了。

说明：这种方法实现起来简单，方便，也不会加大数据库的负担，但是如果客户端把cookie禁掉了的话，那么session就无从同步了，这样会给网站带来损失；cookie的安全性不高，虽然它已经加了密，但是还是可以伪造的。

2、session存在数据库（MySQL等）中

PHP可以配置将session保存在数据库中，这种方法是把存放session的表和其他数据库表放在一起，如果mysql也做了集群了话，每个mysql节点都要有这张表，并且这张session表的数据表要实时同步。

说明：用数据库来同步session，会加大数据库的IO，增加数据库的负担。而且数据库读写速度较慢，不利于session的适时同步。

3、session存在memcache或者redis中

memcache可以做分布式，php配置文件中设置存储方式为memcache，这样php自己会建立一个session集群，将session数据存储在memcache中。

说明：以这种方式来同步session，不会加大数据库的负担，并且安全性比用cookie大大的提高，把session放到内存里面，比从文件中读取要快很多。但是memcache把内存分成很多种规格的存储块，有块就有大小，这种方式也就决定了，memcache不能完全利用内存，会产生内存碎片，如果存储块不足，还会产生内存溢出。

4、nginx中的ip_hash技术能够将某个ip的请求定向到同一台后端，这样一来这个ip下的某个客户端和某个后端就能建立起稳固的session，ip_hash是在upstream配置中定义的：

[html] view plaincopy在CODE上查看代码片派生到我的代码片

upstream nginx.example.com

{

server 192.168.74.235:80;

server 192.168.74.236:80;

ip_hash;

}

server

{

listen 80;

location /

{

proxy_pass

http://nginx.example.com;

}

互联网开发需要掌握的知识:

http

HTTP协议（HyperText Transfer Protocol，超文本传输协议）是用于从WWW服务器传输超文本到本地浏览器的传送协议。它可以使浏览器更加高效，使网络传输减少。它不仅保证计算机正确快速地传输超文本文档，还确定传输文档中的哪一部分，以及哪部分内容首先显示(如文本先于图形)等。HTTP是一个应用层协议，由请求和响应构成，是一个标准的客户端服务器模型。HTTP是一个无状态的协议。

设计模式:

Spring中使用到的设计模式:

1.工厂方法（Factory Method）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

spring中的FactoryBean就是典型的工厂方法模式。如下图：

2.单例（Singleton）

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。

3.适配器（Adapter）

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

spring中在对于aop的处理中有Adapter模式的例子，见如下图：

由于Advisor链需要的是MethodInterceptor对象，所以每一个Advisor中的Advice都要适配成对应的MethodInterceptor对象。

4.代理（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。

spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

5.观察者（Observer）

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

spring中Observer模式常用的地方是listener的实现。如ApplicationListener。

6.策略（Strategy）

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

应用地方: 第一个地方，加载资源文件的方式，使用了不同的方法，比如：ClassPathResourece，FileSystemResource，ServletContextResource，UrlResource但他们都有共同的借口Resource；第二个地方就是在Aop的实现中，采用了两种不同的方式，JDK动态代理和CGLIB代理；

7.模板方法（Template Method）

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Template Method使用的模板方法模式

这里想要探讨另一种对Template Method的理解。spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。

合道金融项目:

合道金融项目主要功能和定位是小额p2p借款业务的线下核心管理系统,它的功能包括管理模块,功能区,财富流程,抵押借款流程,系统批处理模块等功能模块.提供给业务人员和风控人员进行统一协同工作,便于总比对各机构与部门的规划管理.采用Web系统主流框架Struts2,spring,mybatis 提高系统的开发效率,简化数据操作统一规范开发标准.为降低服务维护成本,提高稳定性与数据安全性服务器采用阿里云主机.

我所负责负责财富端流程和借款客户抵押借款流程审批功能的开发；负责合同管理模块的开发;财富端流程的需求是为出借客户提供出借申请网银支付,提前撤资等投资理财的需要,为公司提供申请信息录入,撮合匹配,回款确认,金额明细等一些完整的理财流程.它依赖于第三方支付易宝支付,借款申请,流程模块.申请好生成规范为L+机构12位+时间8位+序号4位.

抵押借款流程的需求是为借款客户提供借款申请，还款还息等借款需要，为公司提供申请信息录入，撮合匹配，风险审核，放款确认，收支明细等一系列完整的借款流程。它依赖于第三方支付，出借申请，流程模块。申请号生成规范B + 机构12 位+ 时间8 位+ 序号4 号

找工作的时候做的Java面试整理

猜你喜欢