1、什么是 ORM 框架？
答：对象-关系映射（Object-Relational Mapping，简称ORM），面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。
2、持久层设计要考虑的问题有哪些？你用过的持久层框架有哪些？
答：所谓"持久"就是将数据保存到可掉电式存储设备中以便今后使用，简单的说，就是将内存中的数据保存到关系型数据库、文件系统、消息队列等提供持久化支持的设备中。持久层就是系统中专注于实现数据持久化的相对独立的层面。
持久层设计的目标包括：
- 数据存储逻辑的分离，提供抽象化的数据访问接口。
- 数据访问底层实现的分离，可以在不修改代码的情况下切换底层实现。
- 资源管理和调度的分离，在数据访问层实现统一的资源调度（如缓存机制）。
- 数据抽象，提供更面向对象的数据操作。
持久层框架有：
- Hibernate
- MyBatis
- TopLink
- Guzz
- jOOQ
- Spring Data
- ActiveJDBC
3、Hibernate中SessionFactory是线程安全的吗？Session是线程安全的吗（两个线程能够共享同一个Session吗）？
SessionFactory对应Hibernate的一个数据存储的概念，它是线程安全的，可以被多个线程并发访问。SessionFactory一般只会在启动的时候构建。对于应用程序，最好将SessionFactory通过单例模式进行封装以便于访问。Session是一个轻量级非线程安全的对象（线程间不能共享session），它表示与数据库进行交互的一个工作单元。Session是由SessionFactory创建的，在任务完成之后它会被关闭。Session是持久层服务对外提供的主要接口。Session会延迟获取数据库连接（也就是在需要的时候才会获取）。为了避免创建太多的session，可以使用ThreadLocal将session和当前线程绑定在一起，这样可以让同一个线程获得的总是同一个session。Hibernate 3中SessionFactory的getCurrentSession()方法就可以做到。
4、Hibernate中Session的load和get方法的区别是什么？
答：主要有以下三项区别：
① 如果没有找到符合条件的记录，get方法返回null，load方法抛出异常。
② get方法直接返回实体类对象，load方法返回实体类对象的代理。
③ 在Hibernate 3之前，get方法只在一级缓存中进行数据查找，如果没有找到对应的数据则越过二级缓存，直接发出SQL语句完成数据读取；load方法则可以从二级缓存中获取数据；从Hibernate 3开始，get方法不再是对二级缓存只写不读，它也是可以访问二级缓存的。
**说明：**对于load()方法Hibernate认为该数据在数据库中一定存在可以放心的使用代理来实现延迟加载，如果没有数据就抛出异常，而通过get()方法获取的数据可以不存在。
5、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法分别是做什么的？有什么区别？
答：Hibernate的对象有三种状态：瞬时态（transient）、持久态（persistent）和游离态（detached）。
瞬时态的实例可以通过调用save()、persist()或者saveOrUpdate()方法变成持久态；游离态的实例可以通过调用update()、saveOrUpdate()、lock()或者replicate()变成持久态。
save()和persist()将会引发SQL的INSERT语句，而update()或merge()会引发UPDATE语句。
save()和update()的区别在于一个是将瞬时态对象变成持久态，一个是将游离态对象变为持久态。
merge()方法可以完成save()和update()方法的功能，它的意图是将新的状态合并到已有的持久化对象上或创建新的持久化对象。
对于persist()方法，按照官方文档的说明：
① persist()方法把一个瞬时态的实例持久化，但是并不保证标识符被立刻填入到持久化实例中，标识符的填入可能被推迟到flush的时间；
② persist()方法保证当它在一个事务外部被调用的时候并不触发一个INSERT语句，当需要封装一个长会话流程的时候，persist()方法是很有必要的；
③ save()方法不保证第②条，它要返回标识符，所以它会立即执行INSERT语句，不管是在事务内部还是外部。
至于lock()方法和update()方法的区别，update()方法是把一个已经更改过的脱管状态的对象变成持久状态；lock()方法是把一个没有更改过的脱管状态的对象变成持久状态。
6、Session加载实体对象的过程。
答：Session加载实体对象的步骤是：
① Session在调用数据库查询功能之前，首先会在一级缓存中通过实体类型和主键进行查找，如果一级缓存查找命中且数据状态合法，则直接返回；
② 如果一级缓存没有命中，接下来Session会在当前NonExists记录（相当于一个查询黑名单，如果出现重复的无效查询可以迅速做出判断，从而提升性能）中进行查找，如果NonExists中存在同样的查询条件，则返回null；
③ 如果一级缓存查询失败则查询二级缓存，如果二级缓存命中则直接返回；
④ 如果之前的查询都未命中，则发出SQL语句，如果查询未发现对应记录则将此次查询添加到Session的NonExists中加以记录，并返回null；
⑤ 根据映射配置和SQL语句得到ResultSet，并创建对应的实体对象；
⑥ 将对象纳入Session（一级缓存）的管理；
⑦ 如果有对应的拦截器，则执行拦截器的onLoad方法；
⑧ 如果开启并设置了要使用二级缓存，则将数据对象纳入二级缓存；
⑨ 返回数据对象。
7、Query接口的list方法和iterate方法有什么区别？
答：
① list()方法无法利用一级缓存和二级缓存（对缓存只写不读），它只能在开启查询缓存的前提下使用查询缓存；iterate()方法可以充分利用缓存，如果目标数据只读或者读取频繁，使用iterate()方法可以减少性能开销。
② list()方法不会引起N+1查询问题，而iterate()方法可能引起N+1查询问题
**说明：**关于N+1查询问题，可以参考CSDN上的一篇文章《什么是N+1查询》
8、Hibernate如何实现分页查询？
答：分页查询就是把数据库中某张表的记录数进行分页查询，在做分页查询时会有一个Page类，下面是一个Page类，我对其做了详细的注解：
package com.entity;import javax.persistence.criteria.CriteriaBuilder;public class Page {/*** 其中currentPage,perPageRows这两个参数是做分页查询必须具备的参数* 原因是：hibernate中的Criteria或则是Query这两个接口：都有setFirstResult(Integer firstResult)* 和setMaxResult(Integer maxResult),* 这里的firstResult就是每页的开始的索引数：* 每页开始的索引数的计算公式是：（currentPage-1）*perPageRows+1,(这是相对索引从1开始的)* 但是Hibernate中的firstResult的索引是从0开始的，所以在hibernate中每页开始的索引数的计算公式是：* (currentPage-1)*perPageRows+1-1=(currentPge-1)*perPageRows.** maxResult就是每页能查询的最大记录数：也就是perPageRows.** Math.ceil(totalRows/perPageRows)==totalPages;//这是根据总记录数和每页的记录数算出总页数的计算公式。*/private Integer currentPage;//当前页private Integer perPageRows;//每页的记录数private Integer totalRows;//总记录数：private Integer totalPages;//总页数：public Integer getCurrentPage() {return currentPage;}public void setCurrentPage(Integer currentPage) {this.currentPage = currentPage;}public Integer getPerPageRows() {return perPageRows;}public void setPerPageRows(Integer perPageRows) {this.perPageRows = perPageRows;}public Integer getTotalRows() {return totalRows;}public void setTotalRows(Integer totalRows) {this.totalRows = totalRows;}public Integer getTotalPages() {return totalPages;}public void setTotalPages(Integer totalPages) {this.totalPages = totalPages;}}
下面用Hibernate的Criteira接口进行查询：
对应的实体类Employee的代码如下：
package com.entity;import javax.persistence.*;@Entity@Table(name = "EMPLOYEE")public class Employee {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private int id;@Column(name = "first_name")private String firstName;@Column(name = "last_name")private String lastName;@Column(name = "salary")private int salary;public Employee() {}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getFirstName() {return firstName;}public void setFirstName(String firstName) {this.firstName = firstName;}public String getLastName() {return lastName;}public void setLastName(String lastName) {this.lastName = lastName;}public int getSalary() {return salary;}public void setSalary(int salary) {this.salary = salary;}}
//创建EMPLOYEE表的sql语句是：
create table EMPLOYEE (id INT NOT NULL auto_increment,first_name VARCHAR(20) default NULL,last_name VARCHAR(20) default NULL,salaryINT default NULL,PRIMARY KEY (id));
首先在写一个配置文件：hibernate.cfg.xml用于连接数据库；
hibernate.cfg.xml的代码如下：
<?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD//EN""/hibernate-configuration-5.0.dtd"><hibernate-configuration><session-factory><property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property><property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property><property name="hibernate.connection.username">root</property><property name="hibernate.connection.password">130850a,</property><property name="hibernate.connection.pool_size">10</property><property name="show_sql">true</property><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="hibernate.current_session_context_class">thread</property><mapping class="com.entity.Employee" /></session-factory></hibernate-configuration>
在写一个用于启动Hibernate的util类：HibernateUtil的代码如下：
package com.util;import org.hibernate.SessionFactory;import org.hibernate.boot.Metadata;import org.hibernate.boot.MetadataSources;import org.hibernate.boot.registry.StandardServiceRegistry;import org.hibernate.boot.registry.StandardServiceRegistryBuilder;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;public class HibernateUtil {private static final SessionFactory sessionFactory;private static ServiceRegistry serviceRegistry;static {try {StandardServiceRegistry standardRegistry =new StandardServiceRegistryBuilder().configure("hibernate.cfg.xml").build();Metadata metaData =new MetadataSources(standardRegistry).getMetadataBuilder().build();sessionFactory = metaData.getSessionFactoryBuilder().build();} catch (Throwable th) {System.err.println("Enitial SessionFactory creation failed" + th);throw new ExceptionInInitializerError(th);}}public static SessionFactory getSessionFactory() {return sessionFactory;}}
最后是分页查询的代码，代码如下：
import com.entity.Employee;import com.entity.Page;import com.util.HibernateUtil;import org.hibernate.Criteria;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import java.util.List;public class PaginationQuery {public void paginationByCriteria(){SessionFactory sessionFactory = HibernateUtil.getSessionFactory();Session session = sessionFactory.getCurrentSession();Transaction tx=null;try {//do some worktx=session.beginTransaction();Page page = new Page();/*** 假设现在查询的是第一页，每页查询的最大记录数是3.*/page.setCurrentPage(1);page.setPerPageRows(3);Criteria criteria = session.createCriteria(Employee.class);Integer currentPage = page.getCurrentPage();//得到当前页Integer perPageRows = page.getPerPageRows();//得到每页的记录数：/*** 在Page类中我已说明了：每页开始的索引数在hibernate中的计算公式是：(currentPage-1)*perPageRows*/criteria.setFirstResult((currentPage-1)*perPageRows);criteria.setMaxResults(perPageRows);List<Employee> employees = criteria.list();for(Employee employee:employees){System.out.println("*********************");System.out.println("id="+employee.getId()+" firstName="+employee.getFirstName()+" lastName="+employee.getLastName());}mit();} catch (Exception e) {if(tx!=null){tx.rollback();}e.printStackTrace();} finally {session.close();//关闭流，一定要关闭，不然会影响运行速度。}}public static void main(String[] args) {PaginationQuery paginationQuery = new PaginationQuery();paginationQuery.paginationByCriteria();}}
9、锁机制有什么用？简述Hibernate的悲观锁和乐观锁机制。
hibernate锁机制，今天写个总结。Hibernate锁机制包括悲观锁和乐观锁。
（1）悲观锁
它指的是对数据被外界修改持保守态度。假定任何时刻存取数据时，都可能有另一个客户也正在存取同一笔数据，为了保持数据被操作的一致性，于是对数据采取了数据库层次的锁定状态，依靠数据库提供的锁机制来实现。
基于jdbc实现的数据库加锁如下：
select * from account where name="Erica" for update
在更新的过程中，数据库处于加锁状态，任何其他的针对本条数据的操作都将被延迟。本次事务提交后解锁。而hibernate悲观锁的具体实现如下：
String sql="查询语句";Query query=session.createQuery(sql);query.setLockMode("对象"，LockModel.UPGRADE);
说到这里，就提到了hibernate的加锁模式：
LockMode.NONE：无锁机制。LockMode.WRITE：Hibernate在Insert和Update记录的时候会自动获取。LockMode.READ：Hibernate在读取记录的时候会自动获取。
这三种加锁模式是供hibernate内部使用的，与数据库加锁无关：
LockMode.UPGRADE：利用数据库的for update字句加锁。
在这里我们要注意的是：只有在查询开始之前（也就是hiernate生成sql语句之前）加锁，才会真正通过数据库的锁机制加锁处理。否则，数据已经通过不包含for updata子句的sql语句加载进来，所谓的数据库加锁也就无从谈起。
但是，从系统的性能上来考虑，对于单机或小系统而言，这并不成问题，然而如果是在网络上的系统，同时间会有许多联机，假设有数以百计或上千甚至更多的并发访问出现，我们该怎么办？如果等到数据库解锁我们再进行下面的操作，我们浪费的资源是多少？–这也就导致了乐观锁的产生。
（2）乐观锁
乐观锁定（optimistic locking）则乐观的认为资料的存取很少发生同时存取的问题，因而不作数据库层次上的锁定，为了维护正确的数据，乐观锁定采用应用程序上的逻辑实现版本控制的方法。
例如若有两个客户端，A客户先读取了账户余额100元，之后B客户也读取了账户余额100元的数据，A客户提取了50元，对数据库作了变更，此时数据库中的余额为50元，B客户也要提取30元，根据其所取得的资料，100-30将为70余额，若此时再对数据库进行变更，最后的余额就会不正确。
在不实行悲观锁定策略的情况下，数据不一致的情况一但发生，有几个解决的方法，一种是先更新为主，一种是后更新的为主，比较复杂的就是检查发生变动的数据来实现，或是检查所有属性来实现乐观锁定。
Hibernate 中透过版本号检查来实现后更新为主，这也是Hibernate所推荐的方式，在数据库中加入一个VERSON栏记录，在读取数据时连同版本号一同读取，并在更新数据时递增版本号，然后比对版本号与数据库中的版本号，如果大于数据库中的版本号则予以更新，否则就回报错误。
以刚才的例子，A客户读取账户余额1000元，并连带读取版本号为5的话，B客户此时也读取账号余额1000元，版本号也为5，A客户在领款后账户余额为500，此时将版本号加1，版本号目前为6，而数据库中版本号为5，所以予以更新，更新数据库后，数据库此时余额为500，版本号为6，B客户领款后要变更数据库，其版本号为5，但是数据库的版本号为6，此时不予更新，B客户数据重新读取数据库中新的数据并重新进行业务流程才变更数据库。
以Hibernate实现版本号控制锁定的话，我们的对象中增加一个version属性，例如：
public class Account {private int version;....public void setVersion(int version) {this.version = version;}public int getVersion() {return version;}....}
而在映像文件中，我们使用optimistic-lock属性设定version控制，属性栏之后增加一个标签，如下：
<hibernate-mapping><class name="onlyfun.caterpillar.Account" talble="ACCOUNT"optimistic-lock="version"><id...../><version name="version" column="VERSION"/>....</class></hibernate-mapping>
设定好版本控制之后，在上例中如果B 客户试图更新数据，将会引发StableObjectStateException例外，我们可以捕捉这个例外，在处理中重新读取数据库中的数据，同时将 B客户目前的数据与数据库中的数据秀出来，让B客户有机会比对不一致的数据，以决定要变更的部份，或者您可以设计程式自动读取新的资料，并重复扣款业务流程，直到数据可以更新为止，这一切可以在背景执行，而不用让您的客户知道。
但是乐观锁也有不能解决的问题存在：上面已经提到过乐观锁机制的实现往往基于系统中的数据存储逻辑，在我们的系统中实现，来自外部系统的用户余额更新不受我们系统的控制，有可能造成非法数据被更新至数据库。因此我们在做电子商务的时候，一定要小心的注意这项存在的问题，采用比较合理的逻辑验证，避免数据执行错误。
也可以在使用Session的load()或是lock()时指定锁定模式以进行锁定。
如果数据库不支持所指定的锁定模式，Hibernate会选择一个合适的锁定替换，而不是丢出一个例外。
10、阐述实体对象的三种状态以及转换关系。
答：最新的Hibernate文档中为Hibernate对象定义了四种状态（原来是三种状态，面试的时候基本上问的也是三种状态），分别是：瞬时态（new, or transient）、持久态（managed, or persistent）、游状态（detached）和移除态（removed，以前Hibernate文档中定义的三种状态中没有移除态），如下图所示，就以前的Hibernate文档中移除态被视为是瞬时态。
瞬时态：当new一个实体对象后，这个对象处于瞬时态，即这个对象只是一个保存临时数据的内存区域，如果没有变量引用这个对象，则会被JVM的垃圾回收机制回收。这个对象所保存的数据与数据库没有任何关系，除非通过Session的save()、saveOrUpdate()、persist()、merge()方法把瞬时态对象与数据库关联，并把数据插入或者更新到数据库，这个对象才转换为持久态对象。持久态：持久态对象的实例在数据库中有对应的记录，并拥有一个持久化标识（ID）。对持久态对象进行delete操作后，数据库中对应的记录将被删除，那么持久态对象与数据库记录不再存在对应关系，持久态对象变成移除态（可以视为瞬时态）。持久态对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。游离态：当Session进行了close()、clear()、evict()或flush()后，实体对象从持久态变成游离态，对象虽然拥有持久和与数据库对应记录一致的标识值，但是因为对象已经从会话中清除掉，对象不在持久化管理之内，所以处于游离态（也叫脱管态）。游离态的对象与临时状态对象是十分相似的，只是它还含有持久化标识。
**提示：**关于这个问题，在Hibernate的官方文档中有更为详细的解读。
11、如何理解Hibernate的延迟加载机制？在实际应用中，延迟加载与Session关闭的矛盾是如何处理的？
延迟加载：延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载，另外在Hibernate3中还提供了对属性的延迟加载。下面我们就分别介绍这些种类的延迟加载的细节。
（1）实体对象的延迟加载：
对于关联实体，可以将其分为两种情况：
①关联实体是多个实体时（包括一对多、多对多）：此时关联实体将以集合的形式存在，Hibernate 将使用 PersistentSet、PersistentList、PersistentMap、PersistentSortedMap、PersistentSortedSet 等集合来管理延迟加载的实体。这就是前面所介绍的情形。
②关联实体是单个实体时（包括一对一、多对一）：当 Hibernate 加载某个实体时，延迟的关联实体将是一个动态生成代理对象。
如果想对实体对象使用延迟加载，必须要在实体的映射配置文件中进行相应的配置，如下所示：
<hibernate-mapping><class name=”com.neusoft.entity.User” table=”user” lazy=”true”>......</class></hibernate-mapping>
通过将class的lazy属性设置为true，来开启实体的延迟加载特性。如果我们运行下面的代码：
User user=(User)session.load(User.class,”1”);（1）
System.out.println(user.getName());（2）
当运行到(1)处时，Hibernate并没有发起对数据的查询，如果我们此时通过一些调试工具(比如JBuilder的Debug工具)，观察此时user对象的内存快照，我们会惊奇的发现，此时返回的可能是User$EnhancerByCGLIB$$bede8986类型的对象，而且其属性为null,这是怎么回事？还记得前面我曾讲过session.load()方法，会返回实体对象的代理类对象，这里所返回的对象类型就是User对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理类对象，并且在代理类对象中包含目标对象的所有属性和方法，而且所有属性均被赋值为null。通过调试器显示的内存快照，我们可以看出此时真正的User对象，是包含在代理对象的CGLIB$CALBACK_0.target属性中，当代码运行到（2）处时，此时调用user.getName()方法，这时通过CGLIB赋予的回调机制，实际上调用CGLIB$CALBACK_0.getName()方法，当调用该方法时，Hibernate会首先检查CGLIB$CALBACK_0.target属性是否为null，如果不为空，则调用目标对象的getName方法，如果为空，则会发起数据库查询，生成类似这样的SQL语句：select * from user where id=’1’;来查询数据，并构造目标对象，并且将它赋值到CGLIB$CALBACK_0.target属性中。
这样，通过一个中间代理对象，Hibernate实现了实体的延迟加载，只有当用户真正发起获得实体对象属性的动作时，才真正会发起数据库查询操作。所以实体的延迟加载是用通过中间代理类完成的，所以只有session.load()方法才会利用实体延迟加载，因为只有session.load()方法才会返回实体类的代理类对象。
（2）集合类型的延迟加载：
在Hibernate的延迟加载机制中，针对集合类型的应用，意义是最为重大的，因为这有可能使性能得到大幅度的提高，为此Hibernate进行了大量的努力，其中包括对JDK Collection的独立实现，我们在一对多关联中，定义的用来容纳关联对象的Set集合，并不是java.util.Set类型或其子类型，而是net.sf.hibernate.collection.Set类型，通过使用自定义集合类的实现，Hibernate实现了集合类型的延迟加载。为了对集合类型使用延迟加载，我们必须如下配置我们的实体类的关于关联的部分：
<hibernate-mapping><class name=”com.neusoft.entity.User” table=”user”>......<set name=”addresses” table=”address” lazy=”true” inverse=”true”><key column=”user_id”/><one-to-many class=”com.neusoft.entity.Arrderss”/></set></class></hibernate-mapping>
通过将元素的lazy属性设置为true来开启集合类型的延迟加载特性。我们看下面的代码：
User user=(User)session.load(User.class,”1”);Collection addset=user.getAddresses(); (1)Iterator it=addset.iterator(); (2)while(it.hasNext()){Address address=(Address)it.next();System.out.println(address.getAddress());}
当程序执行到(1)处时，这时并不会发起对关联数据的查询来加载关联数据，只有运行到(2)处时，真正的数据读取操作才会开始，这时Hibernate会根据缓存中符合条件的数据索引，来查找符合条件的实体对象。
这里我们引入了一个全新的概念——数据索引，下面我们首先将接一下什么是数据索引。在Hibernate中对集合类型进行缓存时，是分两部分进行缓存的，首先缓存集合中所有实体的id列表，然后缓存实体对象，这些实体对象的id列表，就是所谓的数据索引。当查找数据索引时，如果没有找到对应的数据索引，这时就会一条select SQL的执行，获得符合条件的数据，并构造实体对象集合和数据索引，然后返回实体对象的集合，并且将实体对象和数据索引纳入Hibernate的缓存之中。另一方面，如果找到对应的数据索引，则从数据索引中取出id列表，然后根据id在缓存中查找对应的实体，如果找到就从缓存中返回，如果没有找到，在发起select SQL查询。在这里我们看出了另外一个问题，这个问题可能会对性能产生影响，这就是集合类型的缓存策略。如果我们如下配置集合类型：
<hibernate-mapping><class name=”com.neusoft.entity.User” table=”user”>......<set name=”addresses” table=”address” lazy=”true” inverse=”true”><cache usage=”read-only”/><key column=”user_id”/><one-to-many class=”com.neusoft.entity.Arrderss”/></set></class></hibernate-mapping>
这里我们应用了配置，如果采用这种策略来配置集合类型，Hibernate将只会对数据索引进行缓存，而不会对集合中的实体对象进行缓存。如上配置我们运行下面的代码：
User user=(User)session.load(User.class,”1”);Collection addset=user.getAddresses();Iterator it=addset.iterator(); while(it.hasNext()){Address address=(Address)it.next();System.out.println(address.getAddress());}System.out.println(“Second query……”);User user2=(User)session.load(User.class,”1”);Collection it2=user2.getAddresses();while(it2.hasNext()){Address address2=(Address)it2.next();System.out.println(address2.getAddress());}
运行这段代码，会得到类似下面的输出：
Select * from user where id=’1’;Select * from address where user_id=’1’;TianjinDalianSecond query……Select * from address where id=’1’;Select * from address where id=’2’;TianjinDalian
我们看到，当第二次执行查询时，执行了两条对address表的查询操作，为什么会这样？这是因为当第一次加载实体后，根据集合类型缓存策略的配置，只对集合数据索引进行了缓存，而并没有对集合中的实体对象进行缓存，所以在第二次再次加载实体时，Hibernate找到了对应实体的数据索引，但是根据数据索引，却无法在缓存中找到对应的实体，所以Hibernate根据找到的数据索引发起了两条select SQL的查询操作，这里造成了对性能的浪费，怎样才能避免这种情况呢？我们必须对集合类型中的实体也指定缓存策略，所以我们要如下对集合类型进行配置：
<hibernate-mapping><class name=”com.neusoft.entity.User” table=”user”>......<set name=”addresses” table=”address” lazy=”true” inverse=”true”><cache usage=”read-write”/><key column=”user_id”/><one-to-many class=”com.neusoft.entity.Arrderss”/></set></class></hibernate-mapping>
此时Hibernate会对集合类型中的实体也进行缓存，如果根据这个配置再次运行上面的代码，将会得到类似如下的输出：
Select * from user where id=’1’;Select * from address where user_id=’1’;TianjinDalianSecond query……TianjinDalian
这时将不会再有根据数据索引进行查询的SQL语句，因为此时可以直接从缓存中获得集合类型中存放的实体对象。
（3）属性延迟加载
在Hibernate3中，引入了一种新的特性——属性的延迟加载，这个机制又为获取高性能查询提供了有力的工具。当要进行大数据对象读取时，如：在User对象中有一个resume字段，该字段是一个java.sql.Clob类型，包含了用户的简历信息，当我们加载该对象时，我们不得不每一次都要加载这个字段，而不论我们是否真的需要它，而且这种大数据对象的读取本身会带来很大的性能开销。在Hibernate3中，我们可以通过属性延迟加载机制，来使我们获得只有当我们真正需要操作这个字段时，才去读取这个字段数据的能力，为此我们必须如下配置我们的实体类：
<hibernate-mapping><class name=”com.neusoft.entity.User” table=”user”>......<property name=”resume” type=”java.sql.Clob” column=”resume” lazy=”true”/></class></hibernate-mapping>
通过对元素的lazy属性设置true来开启属性的延迟加载，在Hibernate3中为了实现属性的延迟加载，使用了类增强器来对实体类的Class文件进行强化处理，通过增强器的增强，将CGLIB的回调机制逻辑，加入实体类，这里我们可以看出属性的延迟加载，还是通过CGLIB来实现的。CGLIB是Apache的一个开源工程，这个类库可以操纵java类的字节码，根据字节码来动态构造符合要求的类对象。根据上面的配置我们运行下面的代码：
String sql=”from User user where user.name=’zx’ ”;Query query=session.createQuery(sql); (1)List list=query.list();for(int i=0;i<list.size();i++){User user=(User)list.get(i);System.out.println(user.getName());System.out.println(user.getResume()); (2)}
当执行到(1)处时，会生成类似如下的SQL语句：
Select id,age,name from user where name=’zx’;
这时Hibernate会检索User实体中所有非延迟加载属性对应的字段数据，当执行到(2)处时，会生成类似如下的SQL语句：
Select resume from user where id=’1’;
这时会发起对resume字段数据真正的读取操作。
12、举一个多对多关联的例子，并说明如何实现多对多关联映射。
答：例如：商品和订单、学生和课程都是典型的多对多关系。可以在实体类上通过@ManyToMany注解配置多对多关联或者通过映射文件中的和标签配置多对多关联，但是实际项目开发中，很多时候都是将多对多关联映射转换成两个多对一关联映射来实现的。
13、谈一下你对继承映射的理解。
答：继承关系的映射策略有三种：
① 每个继承结构一张表（table per class hierarchy），不管多少个子类都用一张表。
② 每个子类一张表（table per subclass），公共信息放一张表，特有信息放单独的表。
③ 每个具体类一张表（table per concrete class），有多少个子类就有多少张表。
第一种方式属于单表策略，其优点在于查询子类对象的时候无需表连接，查询速度快，适合多态查询；缺点是可能导致表很大。后两种方式属于多表策略，其优点在于数据存储紧凑，其缺点是需要进行连接查询，不适合多态查询。
14、简述Hibernate常见优化策略。
答：这个问题应当挑自己使用过的优化策略回答，常用的有：
① 制定合理的缓存策略（二级缓存、查询缓存）。
② 采用合理的Session管理机制。
③ 尽量使用延迟加载特性。
④ 设定合理的批处理参数。
⑤ 如果可以，选用UUID作为主键生成器。
⑥ 如果可以，选用基于版本号的乐观锁替代悲观锁。
⑦ 在开发过程中, 开启hibernate.show_sql选项查看生成的SQL，从而了解底层的状况；开发完成后关闭此选项。
⑧ 考虑数据库本身的优化，合理的索引、恰当的数据分区策略等都会对持久层的性能带来可观的提升，但这些需要专业的DBA（数据库管理员）提供支持。
15、谈一谈Hibernate的一级缓存、二级缓存和查询缓存。
什么是缓存？
缓存是介于物理数据源与应用程序之间，是对数据库中的数据复制一份临时放在内存中的容器，其作用是为了减少应用程序对物理数据源访问的次数，从而提高了应用程序的运行性能。Hibernate在进行读取数据的时候，根据缓存机制在相应的缓存中查询，如果在缓存中找到了需要的数据(我们把这称做“缓存命 中")，则就直接把命中的数据作为结果加以利用，避免了大量发送SQL语句到数据库查询的性能损耗。
缓存策略提供商：
提供了HashTable缓存，EHCache，OSCache，SwarmCache，jBoss Cathe2，这些缓存机制，其中EHCache，OSCache是不能用于集群环境（Cluster Safe）的，而SwarmCache，jBoss Cathe2是可以的。HashTable缓存主要是用来测试的，只能把对象放在内存中，EHCache，OSCache可以把对象放在内存（memory）中，也可以把对象放在硬盘（disk）上（为什么放到硬盘上？上面解释了）。
Hibernate缓存分类：
（1）Session缓存（又称作事务缓存）：Hibernate内置的，不能卸除。
缓存范围：缓存只能被当前Session对象访问。缓存的生命周期依赖于Session的生命周期，当Session被关闭后，缓存也就结束生命周期。
（2）SessionFactory缓存（又称作应用缓存）：使用第三方插件，可插拔。
缓存范围：缓存被应用范围内的所有session共享,不同的Session可以共享。这些session有可能是并发访问缓存，因此必须对缓存进行更新。缓存的生命周期依赖于应用的生命周期，应用结束时，缓存也就结束了生命周期，二级缓存存在于应用程序范围。
一级缓存：
Hibernate一些与一级缓存相关的操作（时间点）：
数据放入缓存：
save()，当session对象调用save()方法保存一个对象后，该对象会被放入到session的缓存中。get()和load()，当session对象调用get()或load()方法从数据库取出一个对象后，该对象也会被放入到session的缓存中。使用HQL和QBC等从数据库中查询数据。
例如：数据库有一张表如下：
使用get()或load()证明缓存的存在：
public class Client {public static void main(String[] args) {Session session = HibernateUtil.getSessionFactory().openSession();Transaction tx = null;try {/* 开启一个事务 */tx = session.beginTransaction();/* 从数据库中获取id="402881e534fa5a440134fa5a45340002"的Customer对象 */Customer customer1 = (Customer) session.get(Customer.class, "402881e534fa5a440134fa5a45340002");System.out.println("customer.getUsername is" + customer1.getUsername());/* 事务提交 */mit();System.out.println("-------------------------------------");/* 开启一个新事务 */tx = session.beginTransaction();/* 从数据库中获取id="402881e534fa5a440134fa5a45340002"的Customer对象 */Customer customer2 = (Customer) session.get(Customer.class, "402881e534fa5a440134fa5a45340002");System.out.println("customer2.getUsername is" + customer2.getUsername());/* 事务提交 */mit();System.out.println("-------------------------------------");/* 比较两个get()方法获取的对象是否是同一个对象 */System.out.println("customer1 == customer2 result is " + (customer1 == customer2));} catch (Exception e) {if (tx != null) {tx.rollback();}} finally {session.close();}}}
程序控制台输出结果：
Hibernate:selectcustomer0_.id as id0_0_,customer0_.username as username0_0_,customer0_.balance as balance0_0_fromcustomer customer0_wherecustomer0_.id=?customer.getUsername islisi-------------------------------------customer2.getUsername islisi-------------------------------------customer1 == customer2 result is true
其原理是：在同一个Session里面，第一次调用get()方法， Hibernate先检索缓存中是否有该查找对象，发现没有，Hibernate发送SELECT语句到数据库中取出相应的对象，然后将该对象放入缓存中，以便下次使用，第二次调用get()方法，Hibernate先检索缓存中是否有该查找对象，发现正好有该查找对象，就从缓存中取出来，不再去数据库中检索，没有再次发送select语句。
数据从缓存中清除：
evit()将指定的持久化对象从缓存中清除，释放对象所占用的内存资源，指定对象从持久化状态变为脱管状态，从而成为游离对象。clear()将缓存中的所有持久化对象清除，释放其占用的内存资源。
其他缓存操作：
contains()判断指定的对象是否存在于缓存中。flush()刷新缓存区的内容，使之与数据库数据保持同步。
二级缓存：
@Testpublic void testCache2() {Session session1 = sf.openSession();//获得Session1session1.beginTransaction();Category c = (Category)session1.load(Category.class, 1);System.out.println(c.getName());session1.getTransaction().commit();session1.close();Session session2 = sf.openSession();//获得Session2session2.beginTransaction();Category c2 = (Category)session2.load(Category.class, 1);System.out.println(c2.getName());session2.getTransaction().commit();session2.close();}
当我们重启一个Session，第二次调用load或者get方法检索同一个对象的时候会重新查找数据库，会发select语句信息。
原因：一个session不能取另一个session中的缓存。
性能上的问题：假如是多线程同时去取Category这个对象，load一个对象，这个对像本来可以放到内存中的，可是由于是多线程，是分布在不同的session当中的，所以每次都要从数据库中取，这样会带来查询性能较低的问题。
解决方案：使用二级缓存。
什么是二级缓存？
SessionFactory级别的缓存，可以跨越Session存在，可以被多个Session所共享。
适合放到二级缓存中：
（1）经常被访问
（2）改动不大
（3）数量有限
（4）不是很重要的数据，允许出现偶尔并发的数据。
这样的数据非常适合放到二级缓存中的。
用户的权限：用户的数量不大，权限不多，不会经常被改动，经常被访问。
例如组织机构。
思考：什么样的类，里面的对象才适合放到二级缓存中？
改动频繁，类里面对象特别多，BBS好多帖子，这些帖子20000多条，哪些放到缓存中，不能确定。除非你确定有一些经常被访问的，数据量并不大，改动非常少，这样的数据非常适合放到二级缓存中的。
二级缓存实现原理：
Hibernate如何将数据库中的数据放入到二级缓存中？注意，你可以把缓存看做是一个Map对象，它的Key用于存储对象OID，Value用于存储POJO。首先，当我们使用Hibernate从数据库中查询出数据，获取检索的数据后，Hibernate将检索出来的对象的OID放入缓存中key 中，然后将具体的POJO放入value中，等待下一次再次向数据查询数据时，Hibernate根据你提供的OID先检索一级缓存，若有且配置了二级缓存，则检索二级缓存，如果还没有则才向数据库发送SQL语句，然后将查询出来的对象放入缓存中。
使用二级缓存
（1）打开二级缓存：
为Hibernate配置二级缓存：
在主配置文件中hibernate.cfg.xml ：
<!-- 使用二级缓存 --><property name="hibernate.cache.use_second_level_cache">true</property> <!--设置缓存的类型，设置缓存的提供商--><property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
或者当hibernate与Spring整合后直接配到Spring配置文件applicationContext.xml中
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="mappingResources"><list><value>com/lp/ecjtu/model/Employee.hbm.xml</value><value>com/lp/ecjtu/model/Department.hbm.xml</value></list></property><property name="hibernateProperties"><value>hibernate.dialect=org.hibernate.dialect.OracleDialecthibernate.hbm2ddl.auto=updatehibernate.show_sql=truehibernate.format_sql=true hibernate.cache.use_second_level_cache=truehibernate.cache.provider_class=org.hibernate.cache.EhCacheProviderhibernate.generate_statistics=true </value></property></bean>
（2）配置ehcache.xml
<?xml version="1.0" encoding="UTF-8"?><ehcache><!--缓存到硬盘的路径--><diskStore path="d:/ehcache"></diskStore><!--默认设置maxElementsInMemory : 在內存中最大緩存的对象数量。eternal : 缓存的对象是否永远不变。timeToIdleSeconds ：可以操作对象的时间。timeToLiveSeconds ：缓存中对象的生命周期，时间到后查询数据会从数据库中读取。overflowToDisk ：内存满了，是否要缓存到硬盘。--><defaultCache maxElementsInMemory="200" eternal="false" timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></defaultCache><!--指定缓存的对象。下面出现的的属性覆盖上面出现的，没出现的继承上面的。--><cache name="com.suxiaolei.hibernate.pojos.Order" maxElementsInMemory="200" eternal="false" timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></cache></ehcache>
（3）使用二级缓存需要在实体类中加入注解：
需要ehcache-1.2.3.jar包:
还需要 commons_loging1.1.1.jar包
在实体类中通过注解可以配置实用二级缓存：
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
Load默认使用二级缓存，就是当查一个对象的时候，它先会去二级缓存里面去找，如果找到了就不去数据库中查了。
Iterator默认的也会使用二级缓存，有的话就不去数据库里面查了，不发送select语句了。
List默认的往二级缓存中加数据，假如有一个query，把数据拿出来之后会放到二级缓存，但是执行查询的时候不会到二级缓存中查，会在数据库中查。原因每个query中查询条件不一样。
（4）也可以在需要被缓存的对象中hbm文件中的标签下添加一个子标签:
<hibernate-mapping><class name="com.suxiaolei.hibernate.pojos.Order" table="orders"><cache usage="read-only"/><id name="id" type="string"><column name="id"></column><generator class="uuid"></generator></id><property name="orderNumber" column="orderNumber" type="string"></property><property name="cost" column="cost" type="integer"></property><many-to-one name="customer" class="com.suxiaolei.hibernate.pojos.Customer" column="customer_id" cascade="save-update"></many-to-one> </class></hibernate-mapping>
存在一对多的关系，想要在在获取一方的时候将关联的多方缓存起来，需要再集合属性下添加子标签，这里需要将关联的对象的 hbm文件中必须在存在标签下也添加标签，不然Hibernate只会缓存OID。
<hibernate-mapping><class name="com.suxiaolei.hibernate.pojos.Customer" table="customer"><!-- 主键设置 --><id name="id" type="string"><column name="id"></column><generator class="uuid"></generator></id><!-- 属性设置 --><property name="username" column="username" type="string"></property><property name="balance" column="balance" type="integer"></property><set name="orders" inverse="true" cascade="all" lazy="false" fetch="join"><cache usage="read-only"/><key column="customer_id" ></key><one-to-many class="com.suxiaolei.hibernate.pojos.Order"/></set></class></hibernate-mapping>
16、Hibernate中DetachedCriteria类是做什么的？
答：DetachedCriteria和Criteria的用法基本上是一致的，但Criteria是由Session的createCriteria()方法创建的，也就意味着离开创建它的Session，Criteria就无法使用了。DetachedCriteria不需要Session就可以创建（使用DetachedCriteria.forClass()方法创建），所以通常也称其为离线的Criteria，在需要进行查询操作的时候再和Session绑定（调用其getExecutableCriteria(Session)方法），这也就意味着一个DetachedCriteria可以在需要的时候和不同的Session进行绑定。
17、@OneToMany注解的mappedBy属性有什么作用？
答：@OneToMany用来配置一对多关联映射，但通常情况下，一对多关联映射都由多的一方来维护关联关系，例如学生和班级，应该在学生类中添加班级属性来维持学生和班级的关联关系（在数据库中是由学生表中的外键班级编号来维护学生表和班级表的多对一关系），如果要使用双向关联，在班级类中添加一个容器属性来存放学生，并使用@OneToMany注解进行映射，此时mappedBy属性就非常重要。如果使用XML进行配置，可以用标签的inverse="true"设置来达到同样的效果。
18、MyBatis中使用#和$书写占位符有什么区别？
答：#将传入的数据都当成一个字符串，会对传入的数据自动加上引号；$将传入的数据直接显示生成在SQL中。注意：使用$占位符可能会导致SQL注射攻击，能用#的地方就不要使用$，写order by子句的时候应该用$而不是#。
19、解释一下MyBatis中命名空间（namespace）的作用。
在之前版本的 MyBatis 中，命名空间（Namespaces）的作用并不大，是可选的。 但现在，随着命名空间越发重要，你必须指定命名空间。
命名空间的作用有两个，一个是利用更长的全限定名来将不同的语句隔离开来，同时也实现了你上面见到的接口绑定。就算你觉得暂时用不到接口绑定，你也应该遵循这里的规定，以防哪天你改变了主意。 长远来看，只要将命名空间置于合适的 Java 包命名空间之中，你的代码会变得更加整洁，也有利于你更方便地使用 MyBatis。
命名解析：为了减少输入量，MyBatis 对所有具有名称的配置元素（包括语句，结果映射，缓存等）使用了如下的命名解析规则。
全限定名（比如 “com.mypackage.MyMapper.selectAllThings）将被直接用于查找及使用。短名称（比如 “selectAllThings”）如果全局唯一也可以作为一个单独的引用。 如果不唯一，有两个或两个以上的相同名称（比如 “com.foo.selectAllThings” 和 “com.bar.selectAllThings”），那么使用时就会产生“短名称不唯一”的错误，这种情况下就必须使用全限定名。
20、MyBatis中的动态SQL是什么意思？
答：对于一些复杂的查询，我们可能会指定多个查询条件，但是这些条件可能存在也可能不存在，例如在58同城上面找房子，我们可能会指定面积、楼层和所在位置来查找房源，也可能会指定面积、价格、户型和所在位置来查找房源，此时就需要根据用户指定的条件动态生成SQL语句。如果不使用持久层框架我们可能需要自己拼装SQL语句，还好MyBatis提供了动态SQL的功能来解决这个问题。MyBatis中用于实现动态SQL的元素主要有：
- if
- choose / when / otherwise
- trim
- where
- set
- foreach
下面是映射文件的片段。
<select id="foo" parameterType="Blog" resultType="Blog">select * from t_blog where 1 = 1<if test="title != null">and title = #{title}</if><if test="content != null">and content = #{content}</if><if test="owner != null">and owner = #{owner}</if></select>
当然也可以像下面这些书写。
<select id="foo" parameterType="Blog" resultType="Blog">select * from t_blog where 1 = 1 <choose><when test="title != null">and title = #{title}</when><when test="content != null">and content = #{content}</when><otherwise>and owner = "owner1"</otherwise></choose></select>
再看看下面这个例子。
<select id="bar" resultType="Blog">select * from t_blog where id in<foreach collection="array" index="index" item="item" open="(" separator="," close=")">#{item}</foreach></select>
21、什么是IoC和DI？DI是如何实现的？
答：IoC叫控制反转，是Inversion of Control的缩写，DI（Dependency Injection）叫依赖注入，是对IoC更简单的诠释。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。所谓的"控制反转"就是对组件对象控制权的转移，从程序代码本身转移到了外部容器，由容器来创建对象并管理对象之间的依赖关系。IoC体现了好莱坞原则 - “Don’t call me, we will call you”。依赖注入的基本原则是应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由容器负责，查找资源的逻辑应该从应用组件的代码中抽取出来，交给容器来完成。DI是对IoC更准确的描述，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中。
举个例子：一个类A需要用到接口B中的方法，那么就需要为类A和接口B建立关联或依赖关系，最原始的方法是在类A中创建一个接口B的实现类C的实例，但这种方法需要开发人员自行维护二者的依赖关系，也就是说当依赖关系发生变动的时候需要修改代码并重新构建整个系统。如果通过一个容器来管理这些对象以及对象的依赖关系，则只需要在类A中定义好用于关联接口B的方法（构造器或setter方法），将类A和接口B的实现类C放入容器中，通过对容器的配置来实现二者的关联。
依赖注入可以通过setter方法注入（设值注入）、构造器注入和接口注入三种方式来实现，Spring支持setter注入和构造器注入，通常使用构造器注入来注入必须的依赖关系，对于可选的依赖关系，则setter注入是更好的选择，setter注入需要类提供无参构造器或者无参的静态工厂方法来创建对象。
22、Spring中Bean的作用域有哪些？
Spring 3中为Bean定义了5中作用域，分别为singleton（单例）、prototype（原型）、request、session和global session，5种作用域说明如下：
singleton：单例模式，Spring IoC容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，始终指向同一对象。Singleton作用域是Spring中的缺省作用域，也可以显示的将Bean定义为singleton模式，配置为：<bean id="userDao" class="com.ioc.UserDaoImpl" scope="singleton"/>
prototype：原型模式，每次通过Spring容器获取prototype定义的bean时，容器都将创建一个新的Bean实例，每个Bean实例都有自己的属性和状态，而singleton全局只有一个对象。根据经验，对有状态的bean使用prototype作用域，而对无状态的bean使用singleton作用域。
request：在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前Http Request内有效。
<bean id="loginAction" class="blogs.Login" scope="request"/>,针对每一次Http请求，Spring容器根据该bean的定义创建一个全新的实例，且该实例仅在当前Http请求内有效，而其它请求无法看到当前请求中状态的变化，当当前Http请求结束，该bean实例也将会被销毁。
session：在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean实例仅在当前Session内有效。
<bean id="userPreference" class="com.ioc.UserPreference" scope="session"/>,同Http请求相同，每一次session请求创建新的实例，而不同的实例之间不共享属性，且实例仅在自己的session请求内有效，请求结束，则实例将被销毁。
global Session：在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context时有效。
23、解释一下什么叫AOP（面向切面编程）？
在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫AOP
AOP 的目的：
AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。
AOP 当中的概念：
切入点（Pointcut）
在哪些类，哪些方法上切入（where）通知（Advice）
在方法执行的什么实际（when:方法前/方法后/方法前后）做什么（what:增强的功能）切面（Aspect）
切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！织入（Weaving）
把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）
例子：
为了更好的说明 AOP 的概念，我们来举一个实际中的例子来说明：
在上面的例子中，包租婆的核心业务就是签合同，收房租，那么这就够了，灰色框起来的部分都是重复且边缘的事，交给中介商就好了，这就是 AOP 的一个思想：让关注点代码与业务代码分离！
实际的代码：
我们来实际的用代码感受一下
1.在 Package【pojo】下新建一个【Landlord】类：
package pojo;import org.ponent;@Component("landlord")public class Landlord {public void service() {// 仅仅只是实现了核心的业务功能System.out.println("签合同");System.out.println("收房租");}}
2.在 Package【aspect】下新建一个中介商【Broker】类：
package aspect;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.ponent;@Component@Aspectclass Broker {@Before("execution(* pojo.Landlord.service())")public void before(){System.out.println("带租客看房");System.out.println("谈价格");}@After("execution(* pojo.Landlord.service())")public void after(){System.out.println("交钥匙");}}
3.在 applicationContext.xml 中配置自动注入，并告诉 Spring IoC 容器去哪里扫描这两个 Bean：
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd /schema/context /schema/context/spring-context.xsd /schema/aop /schema/aop/spring-aop.xsd"><context:component-scan base-package="aspect" /><context:component-scan base-package="pojo" /><aop:aspectj-autoproxy/></beans>
4.在 Package【test】下编写测试代码：
package test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import pojo.Landlord;public class TestSpring {public static void main(String[] args) {ApplicationContext context =new ClassPathXmlApplicationContext("applicationContext.xml");Landlord landlord = (Landlord) context.getBean("landlord", Landlord.class);landlord.service();}}
5.执行结果：
带租客看房谈价格签合同收房租交钥匙
这个例子使用了一些注解，现在看不懂没有关系，但我们可以从上面可以看到，我们在 Landlord 的 service() 方法中仅仅实现了核心的业务代码，其余的关注点功能是根据我们设置的切面自动补全的。
使用注解来开发 Spring AOP
使用注解的方式已经逐渐成为了主流，所以我们利用上面的例子来说明如何用注解来开发 Spring AOP
第一步：选择连接点
Spring 是方法级别的 AOP 框架，我们主要也是以某个类额某个方法作为连接点，另一种说法就是：选择哪一个类的哪一方法用以增强功能。
....public void service() {// 仅仅只是实现了核心的业务功能System.out.println("签合同");System.out.println("收房租");}....
我们在这里就选择上述 Landlord 类中的 service() 方法作为连接点。
第二步：创建切面
选择好了连接点就可以创建切面了，我们可以把切面理解为一个拦截器，当程序运行到连接点的时候，被拦截下来，在开头加入了初始化的方法，在结尾也加入了销毁的方法而已，在 Spring 中只要使用 @Aspect 注解一个类，那么 Spring IoC 容器就会认为这是一个切面了：
package aspect;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.ponent;@Component@Aspectclass Broker {@Before("execution(* pojo.Landlord.service())")public void before(){System.out.println("带租客看房");System.out.println("谈价格");}@After("execution(* pojo.Landlord.service())")public void after(){System.out.println("交钥匙");}}
注意： 被定义为切面的类仍然是一个 Bean ，需要 @Component 注解标注
代码部分中在方法上面的注解看名字也能猜出个大概，下面来列举一下 Spring 中的 AspectJ 注解：
注解 说明
@Before 前置通知，在连接点方法前调用
@Around 环绕通知，它将覆盖原有方法，但是允许你通过反射调用原有方法，后面会讲
@After 后置通知，在连接点方法后调用
@AfterReturning 返回通知，在连接点方法执行并正常返回后调用，要求连接点方法在执行过程中没有发生异常
@AfterThrowing 异常通知，当连接点方法异常时调用
有了上表，我们就知道 before() 方法是连接点方法调用前调用的方法，而 after() 方法则相反，这些注解中间使用了定义切点的正则式，也就是告诉 Spring AOP 需要拦截什么对象的什么方法，下面讲到。
第三步：定义切点
在上面的注解中定义了 execution 的正则表达式，Spring 通过这个正则表达式判断具体要拦截的是哪一个类的哪一个方法：
execution(* pojo.Landlord.service())
依次对这个表达式作出分析：
execution：代表执行方法的时候会触发*：代表任意返回类型的方法pojo.Landlord：代表类的全限定名service()：被拦截的方法名称
通过上面的表达式，Spring 就会知道应该拦截 pojo.Lnadlord 类下的 service() 方法。上面的演示类还好，如果多出都需要写这样的表达式难免会有些复杂，我们可以通过使用 @Pointcut 注解来定义一个切点来避免这样的麻烦：
package aspect;import org.aspectj.lang.annotation.After;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;import org.ponent;@Component@Aspectclass Broker {@Pointcut("execution(* pojo.Landlord.service())")public void lService() {}@Before("lService()")public void before() {System.out.println("带租客看房");System.out.println("谈价格");}@After("lService()")public void after() {System.out.println("交钥匙");}}
第四步：测试 AOP
编写测试代码，但是我这里因为 JDK 版本不兼容出现了 BUG…（尴尬…）
这就告诉我们：环境配置很重要…不然莫名其妙的 BUG 让你崩溃…
环绕通知
我们来探讨一下环绕通知，这是 Spring AOP 中最强大的通知，因为它集成了前置通知和后置通知，它保留了连接点原有的方法的功能，所以它及强大又灵活，让我们来看看：
package aspect;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.ponent;@Component@Aspectclass Broker {// 注释掉之前的 @Before 和 @After 注解以及对应的方法// @Before("execution(* pojo.Landlord.service())")// public void before() {//System.out.println("带租客看房");//System.out.println("谈价格");// }//// @After("execution(* pojo.Landlord.service())")// public void after() {//System.out.println("交钥匙");// }// 使用 @Around 注解来同时完成前置和后置通知@Around("execution(* pojo.Landlord.service())")public void around(ProceedingJoinPoint joinPoint) {System.out.println("带租客看房");System.out.println("谈价格");try {joinPoint.proceed();} catch (Throwable throwable) {throwable.printStackTrace();}System.out.println("交钥匙");}}
运行测试代码，结果仍然正确：
带租客看房谈价格签合同收房租交钥匙
使用 XML 配置开发 Spring AOP
注解是很强大的东西，但基于 XML 的开发我们仍然需要了解，我们先来了解一下 AOP 中可以配置的元素：
有了之前通过注解来编写的经验，并且有了上面的表，我们将上面的例子改写成 XML 配置很容易（去掉所有的注解）：
<!-- 装配 Bean--><bean name="landlord" class="pojo.Landlord"/><bean id="broker" class="aspect.Broker"/><!-- 配置AOP --><aop:config><!-- where：在哪些地方（包.类.方法）做增加 --><aop:pointcut id="landlordPoint"expression="execution(* pojo.Landlord.service())"/><!-- what:做什么增强 --><aop:aspect id="logAspect" ref="broker"><!-- when:在什么时机（方法前/后/前后） --><aop:around pointcut-ref="landlordPoint" method="around"/></aop:aspect></aop:config>
运行测试程序，看到正确结果：
带租客看房谈价格签合同收房租交钥匙
24、Spring中自动装配的方式有哪些？
答：
– no，该选项是spring框架的默认选项，表示自动装配为关闭状态OFF。我们必须在bean定义中使用<property>标签显式设置依赖项。
byName，此选项启用基于bean名称的依赖项注入。在Bean中自动装配属性时，属性名称用于在配置文件中搜索匹配的Bean定义。如果找到这样的bean，则将其注入属性。如果找不到这样的bean，则会引发错误。byType，此选项支持基于bean类型的依赖项注入。在bean中自动装配属性时，属性的类类型用于在配置文件中搜索匹配的bean定义。如果找到这样的bean，就在属性中注入它。如果没有找到这样的bean，就会引发一个错误。constructor，通过构造函数自动装配与byType相似，仅适用于构造函数参数。在启用了自动装配的bean中，它将查找构造函数参数的类类型，然后对所有构造函数参数执行自动装配类型。请注意，如果容器中没有一个完全属于构造函数参数类型的bean，则会引发致命错误。
25、Spring中如何使用注解来配置Bean？有哪些相关的注解？
答：首先需要在Spring配置文件中增加如下配置：
<context:component-scan base-package="org.example"/>
然后可以用@Component、@Controller、@Service、@Repository注解来标注需要由Spring IoC容器进行对象托管的类。这几个注解没有本质区别，只不过@Controller通常用于控制器，@Service通常用于业务逻辑类，@Repository通常用于仓储类（例如我们的DAO实现类），普通的类用@Component来标注。
26、Spring支持的事务管理类型有哪些？你在项目中使用哪种方式？
答：Spring支持编程式事务管理和声明式事务管理。许多Spring框架的用户选择声明式事务管理，因为这种方式和应用程序的关联较少，因此更加符合轻量级容器的概念。声明式事务管理要优于编程式事务管理，尽管在灵活性方面它弱于编程式事务管理，因为编程式事务允许你通过代码控制业务。
事务分为全局事务和局部事务。全局事务由应用服务器管理，需要底层服务器JTA支持（如WebLogic、WildFly等）。局部事务和底层采用的持久化方案有关，例如使用JDBC进行持久化时，需要使用Connetion对象来操作事务；而采用Hibernate进行持久化时，需要使用Session对象来操作事务。
Spring提供了如下所示的事务管理器。
这些事务的父接口都是PlatformTransactionManager。Spring的事务管理机制是一种典型的策略模式，PlatformTransactionManager代表事务管理接口，该接口定义了三个方法，该接口并不知道底层如何管理事务，但是它的实现类必须提供getTransaction()方法（开启事务）、commit()方法（提交事务）、rollback()方法（回滚事务）的多态实现，这样就可以用不同的实现类代表不同的事务管理策略。使用JTA全局事务策略时，需要底层应用服务器支持，而不同的应用服务器所提供的JTA全局事务可能存在细节上的差异，因此实际配置全局事务管理器是可能需要使用JtaTransactionManager的子类，如：WebLogicJtaTransactionManager（Oracle的WebLogic服务器提供）、UowJtaTransactionManager（IBM的WebSphere服务器提供）等。
编程式事务管理如下所示。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"xmlns:p="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/context /schema/context/spring-context.xsd"><context:component-scan base-package="com.hzy"/><bean id="propertyConfig"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="location"><value>jdbc.properties</value></property></bean><bean id="dataSource" class="mons.dbcp.BasicDataSource"><property name="driverClassName"><value>${db.driver}</value></property><property name="url"><value>${db.url}</value></property><property name="username"><value>${db.username}</value></property><property name="password"><value>${db.password}</value></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource"><ref bean="dataSource" /></property></bean><!-- JDBC事务管理器 --><bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"scope="singleton"><property name="dataSource"><ref bean="dataSource" /></property></bean><!-- 声明事务模板 --><bean id="transactionTemplate"class="org.springframework.transaction.support.TransactionTemplate"><property name="transactionManager"><ref bean="transactionManager" /></property></bean></beans>
package com.hzy.dao.impl;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import com.hzy.dao.EmpDao;import com.hzy.entity.Emp;@Repositorypublic class EmpDaoImpl implements EmpDao {@Autowiredprivate JdbcTemplate jdbcTemplate;@Overridepublic boolean save(Emp emp) {String sql = "insert into emp values (?,?,?)";return jdbcTemplate.update(sql, emp.getId(), emp.getName(), emp.getBirthday()) == 1;}}
package com.hzy.biz.impl;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.transaction.TransactionStatus;import org.springframework.transaction.support.TransactionCallbackWithoutResult;import org.springframework.transaction.support.TransactionTemplate;import com.hzy.biz.EmpService;import com.hzy.dao.EmpDao;import com.hzy.entity.Emp;@Servicepublic class EmpServiceImpl implements EmpService {@Autowiredprivate TransactionTemplate txTemplate;@Autowiredprivate EmpDao empDao;@Overridepublic void addEmp(final Emp emp) {txTemplate.execute(new TransactionCallbackWithoutResult() {@Overrideprotected void doInTransactionWithoutResult(TransactionStatus txStatus) {empDao.save(emp);}});}}
声明式事务如下图所示，以Spring整合Hibernate 3为例，包括完整的DAO和业务逻辑代码。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop" xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.2.xsd/schema/context/schema/context/spring-context-3.2.xsd/schema/aop/schema/aop/spring-aop-3.2.xsd/schema/tx/schema/tx/spring-tx-3.2.xsd"><!-- 配置由Spring IoC容器托管的对象对应的被注解的类所在的包 --><context:component-scan base-package="com.hzy" /><!-- 配置通过自动生成代理实现AOP功能 --><aop:aspectj-autoproxy /><!-- 配置数据库连接池 (DBCP) --><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><!-- 配置驱动程序类 --><property name="driverClassName" value="com.mysql.jdbc.Driver" /><!-- 配置连接数据库的URL --><property name="url" value="jdbc:mysql://localhost:3306/myweb" /><!-- 配置访问数据库的用户名 --><property name="username" value="root" /><!-- 配置访问数据库的口令 --><property name="password" value="123456" /><!-- 配置最大连接数 --><property name="maxActive" value="150" /><!-- 配置最小空闲连接数 --><property name="minIdle" value="5" /><!-- 配置最大空闲连接数 --><property name="maxIdle" value="20" /><!-- 配置初始连接数 --><property name="initialSize" value="10" /><!-- 配置连接被泄露时是否生成日志 --><property name="logAbandoned" value="true" /><!-- 配置是否删除超时连接 --><property name="removeAbandoned" value="true" /><!-- 配置删除超时连接的超时门限值(以秒为单位) --><property name="removeAbandonedTimeout" value="120" /><!-- 配置超时等待时间(以毫秒为单位) --><property name="maxWait" value="5000" /><!-- 配置空闲连接回收器线程运行的时间间隔(以毫秒为单位) --><property name="timeBetweenEvictionRunsMillis" value="300000" /><!-- 配置连接空闲多长时间后(以毫秒为单位)被断开连接 --><property name="minEvictableIdleTimeMillis" value="60000" /></bean><!-- 配置Spring提供的支持注解ORM映射的Hibernate会话工厂 --><bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"><!-- 通过setter注入数据源属性 --><property name="dataSource" ref="dataSource" /><!-- 配置实体类所在的包 --><property name="packagesToScan" value="com.hzy.entity" /><!-- 配置Hibernate的相关属性 --><property name="hibernateProperties"><!-- 在项目调试完成后要删除show_sql和format_sql属性否则对性能有显著影响 --><value>hibernate.dialect=org.hibernate.dialect.MySQL5Dialect</value></property></bean><!-- 配置Spring提供的Hibernate事务管理器 --><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"><!-- 通过setter注入Hibernate会话工厂 --><property name="sessionFactory" ref="sessionFactory" /></bean><!-- 配置基于注解配置声明式事务 --><tx:annotation-driven /></beans>
package com.hzy.dao;import java.io.Serializable;import java.util.List;import m.QueryBean;import m.QueryResult;/*** 数据访问对象接口(以对象为单位封装CRUD操作)** @param <E> 实体类型* @param <K> 实体标识字段的类型*/public interface BaseDao <E, K extends Serializable> {/*** 新增* @param entity 业务实体对象* @return 增加成功返回实体对象的标识*/public K save(E entity);/*** 删除* @param entity 业务实体对象*/public void delete(E entity);/*** 根据ID删除* @param id 业务实体对象的标识* @return 删除成功返回true否则返回false*/public boolean deleteById(K id);/*** 修改* @param entity 业务实体对象* @return 修改成功返回true否则返回false*/public void update(E entity);/*** 根据ID查找业务实体对象* @param id 业务实体对象的标识* @return 业务实体对象对象或null*/public E findById(K id);/*** 根据ID查找业务实体对象* @param id 业务实体对象的标识* @param lazy 是否使用延迟加载* @return 业务实体对象对象*/public E findById(K id, boolean lazy);/*** 查找所有业务实体对象* @return 装所有业务实体对象的列表容器*/public List<E> findAll();/*** 分页查找业务实体对象* @param page 页码* @param size 页面大小* @return 查询结果对象*/public QueryResult<E> findByPage(int page, int size);/*** 分页查找业务实体对象* @param queryBean 查询条件对象* @param page 页码* @param size 页面大小* @return 查询结果对象*/public QueryResult<E> findByPage(QueryBean queryBean, int page, int size);}
package com.hzy.dao;import java.io.Serializable;import java.util.List;import m.QueryBean;import m.QueryResult;/*** BaseDao的缺省适配器** @param <E> 实体类型* @param <K> 实体标识字段的类型*/public abstract class BaseDaoAdapter<E, K extends Serializable> implementsBaseDao<E, K> {@Overridepublic K save(E entity) {return null;}@Overridepublic void delete(E entity) {}@Overridepublic boolean deleteById(K id) {E entity = findById(id);if(entity != null) {delete(entity);return true;}return false;}@Overridepublic void update(E entity) {}@Overridepublic E findById(K id) {return null;}@Overridepublic E findById(K id, boolean lazy) {return null;}@Overridepublic List<E> findAll() {return null;}@Overridepublic QueryResult<E> findByPage(int page, int size) {return null;}@Overridepublic QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {return null;}}
package com.hzy.dao;import java.io.Serializable;import java.lang.reflect.ParameterizedType;import java.util.ArrayList;import java.util.Collections;import java.util.List;import org.hibernate.Query;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.springframework.beans.factory.annotation.Autowired;import m.HQLQueryBean;import m.QueryBean;import m.QueryResult;/*** 基于Hibernate的BaseDao实现类** @param <E> 实体类型* @param <K> 主键类型*/@SuppressWarnings(value = {"unchecked"})public abstract class BaseDaoHibernateImpl<E, K extends Serializable> extends BaseDaoAdapter<E, K> {@Autowiredprotected SessionFactory sessionFactory;private Class<?> entityClass; // 业务实体的类对象private String entityName;// 业务实体的名字public BaseDaoHibernateImpl() {ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();entityClass = (Class<?>) pt.getActualTypeArguments()[0];entityName = entityClass.getSimpleName();}@Overridepublic K save(E entity) {return (K) sessionFactory.getCurrentSession().save(entity);}@Overridepublic void delete(E entity) {sessionFactory.getCurrentSession().delete(entity);}@Overridepublic void update(E entity) {sessionFactory.getCurrentSession().update(entity);}@Overridepublic E findById(K id) {return findById(id, false);}@Overridepublic E findById(K id, boolean lazy) {Session session = sessionFactory.getCurrentSession();return (E) (lazy? session.load(entityClass, id) : session.get(entityClass, id));}@Overridepublic List<E> findAll() {return sessionFactory.getCurrentSession().createCriteria(entityClass).list();}@Overridepublic QueryResult<E> findByPage(int page, int size) {return new QueryResult<E>(findByHQLAndPage("from " + entityName , page, size),getCountByHQL("select count(*) from " + entityName));}@Overridepublic QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {if(queryBean instanceof HQLQueryBean) {HQLQueryBean hqlQueryBean = (HQLQueryBean) queryBean;return new QueryResult<E>(findByHQLAndPage(hqlQueryBean.getQueryString(), page, size, hqlQueryBean.getParameters()),getCountByHQL(hqlQueryBean.getCountString(), hqlQueryBean.getParameters()));}return null;}/*** 根据HQL和可变参数列表进行查询* @param hql 基于HQL的查询语句* @param params 可变参数列表* @return 持有查询结果的列表容器或空列表容器*/protected List<E> findByHQL(String hql, Object... params) {return this.findByHQL(hql, getParamList(params));}/*** 根据HQL和参数列表进行查询* @param hql 基于HQL的查询语句* @param params 查询参数列表* @return 持有查询结果的列表容器或空列表容器*/protected List<E> findByHQL(String hql, List<Object> params) {List<E> list = createQuery(hql, params).list();return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;}/*** 根据HQL和参数列表进行分页查询* @param hql 基于HQL的查询语句* @page 页码* @size 页面大小* @param params 可变参数列表* @return 持有查询结果的列表容器或空列表容器*/protected List<E> findByHQLAndPage(String hql, int page, int size, Object... params) {return this.findByHQLAndPage(hql, page, size, getParamList(params));}/*** 根据HQL和参数列表进行分页查询* @param hql 基于HQL的查询语句* @page 页码* @size 页面大小* @param params 查询参数列表* @return 持有查询结果的列表容器或空列表容器*/protected List<E> findByHQLAndPage(String hql, int page, int size, List<Object> params) {List<E> list = createQuery(hql, params).setFirstResult((page - 1) * size).setMaxResults(size).list();return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;}/*** 查询满足条件的记录数* @param hql 基于HQL的查询语句* @param params 可变参数列表* @return 满足查询条件的总记录数*/protected long getCountByHQL(String hql, Object... params) {return this.getCountByHQL(hql, getParamList(params));}/*** 查询满足条件的记录数* @param hql 基于HQL的查询语句* @param params 参数列表容器* @return 满足查询条件的总记录数*/protected long getCountByHQL(String hql, List<Object> params) {return (Long) createQuery(hql, params).uniqueResult();}// 创建Hibernate查询对象(Query)private Query createQuery(String hql, List<Object> params) {Query query = sessionFactory.getCurrentSession().createQuery(hql);for(int i = 0; i < params.size(); i++) {query.setParameter(i, params.get(i));}return query;}// 将可变参数列表组装成列表容器private List<Object> getParamList(Object... params) {List<Object> paramList = new ArrayList<>();if(params != null) {for(int i = 0; i < params.length; i++) {paramList.add(params[i]);}}return paramList.size() == 0? Collections.EMPTY_LIST : paramList;}}
package m;import java.util.List;/*** 查询条件的接口**/public interface QueryBean {/*** 添加排序字段* @param fieldName 用于排序的字段* @param asc 升序还是降序* @return 查询条件对象自身(方便级联编程)*/public QueryBean addOrder(String fieldName, boolean asc);/*** 添加排序字段* @param available 是否添加此排序字段* @param fieldName 用于排序的字段* @param asc 升序还是降序* @return 查询条件对象自身(方便级联编程)*/public QueryBean addOrder(boolean available, String fieldName, boolean asc);/*** 添加查询条件* @param condition 条件* @param params 替换掉条件中参数占位符的参数* @return 查询条件对象自身(方便级联编程)*/public QueryBean addCondition(String condition, Object... params);/*** 添加查询条件* @param available 是否需要添加此条件* @param condition 条件* @param params 替换掉条件中参数占位符的参数* @return 查询条件对象自身(方便级联编程)*/public QueryBean addCondition(boolean available, String condition, Object... params);/*** 获得查询语句* @return 查询语句*/public String getQueryString();/*** 获取查询记录数的查询语句* @return 查询记录数的查询语句*/public String getCountString();/*** 获得查询参数* @return 查询参数的列表容器*/public List<Object> getParameters();}
package m;import java.util.List;/*** 查询结果** @param <T> 泛型参数*/public class QueryResult<T> {private List<T> result;// 持有查询结果的列表容器private long totalRecords; // 查询到的总记录数/*** 构造器*/public QueryResult() {}/*** 构造器* @param result 持有查询结果的列表容器* @param totalRecords 查询到的总记录数*/public QueryResult(List<T> result, long totalRecords) {this.result = result;this.totalRecords = totalRecords;}public List<T> getResult() {return result;}public void setResult(List<T> result) {this.result = result;}public long getTotalRecords() {return totalRecords;}public void setTotalRecords(long totalRecords) {this.totalRecords = totalRecords;}}
package com.hzy.dao;import m.QueryResult;import com.hzy.entity.Dept;/*** 部门数据访问对象接口**/public interface DeptDao extends BaseDao<Dept, Integer> {/*** 分页查询顶级部门* @param page 页码* @param size 页码大小* @return 查询结果对象*/public QueryResult<Dept> findTopDeptByPage(int page, int size);}
package com.hzy.dao.impl;import java.util.List;import org.springframework.stereotype.Repository;import m.QueryResult;import com.hzy.dao.BaseDaoHibernateImpl;import com.hzy.dao.DeptDao;import com.hzy.entity.Dept;@Repositorypublic class DeptDaoImpl extends BaseDaoHibernateImpl<Dept, Integer> implements DeptDao {private static final String HQL_FIND_TOP_DEPT = " from Dept as d where d.superiorDept is null ";@Overridepublic QueryResult<Dept> findTopDeptByPage(int page, int size) {List<Dept> list = findByHQLAndPage(HQL_FIND_TOP_DEPT, page, size);long totalRecords = getCountByHQL(" select count(*) " + HQL_FIND_TOP_DEPT);return new QueryResult<>(list, totalRecords);}}
package m;import java.util.List;/*** 分页器** @param <T> 分页数据对象的类型*/public class PageBean<T> {private static final int DEFAUL_INIT_PAGE = 1;private static final int DEFAULT_PAGE_SIZE = 10;private static final int DEFAULT_PAGE_COUNT = 5;private List<T> data; // 分页数据private PageRange pageRange; // 页码范围private int totalPage;// 总页数private int size;// 页面大小private int currentPage; // 当前页码private int pageCount;// 页码数量/*** 构造器* @param currentPage 当前页码* @param size 页码大小* @param pageCount 页码数量*/public PageBean(int currentPage, int size, int pageCount) {this.currentPage = currentPage > 0 ? currentPage : 1;this.size = size > 0 ? size : DEFAULT_PAGE_SIZE;this.pageCount = pageCount > 0 ? size : DEFAULT_PAGE_COUNT;}/*** 构造器* @param currentPage 当前页码* @param size 页码大小*/public PageBean(int currentPage, int size) {this(currentPage, size, DEFAULT_PAGE_COUNT);}/*** 构造器* @param currentPage 当前页码*/public PageBean(int currentPage) {this(currentPage, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);}/*** 构造器*/public PageBean() {this(DEFAUL_INIT_PAGE, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);}public List<T> getData() {return data;}public int getStartPage() {return pageRange != null ? pageRange.getStartPage() : 1;}public int getEndPage() {return pageRange != null ? pageRange.getEndPage() : 1;}public long getTotalPage() {return totalPage;}public int getSize() {return size;}public int getCurrentPage() {return currentPage;}/*** 将查询结果转换为分页数据* @param queryResult 查询结果对象*/public void transferQueryResult(QueryResult<T> queryResult) {long totalRecords = queryResult.getTotalRecords();data = queryResult.getResult();totalPage = (int) ((totalRecords + size - 1) / size); totalPage = totalPage >= 0 ? totalPage : Integer.MAX_VALUE;this.pageRange = new PageRange(pageCount, currentPage, totalPage);}}
package m;/*** 页码范围**/public class PageRange {private int startPage; // 起始页码private int endPage; // 终止页码/*** 构造器* @param pageCount 总共显示几个页码* @param currentPage 当前页码* @param totalPage 总页数*/public PageRange(int pageCount, int currentPage, int totalPage) {startPage = currentPage - (pageCount - 1) / 2;endPage = currentPage + pageCount / 2;if(startPage < 1) {startPage = 1;endPage = totalPage > pageCount ? pageCount : totalPage;}if (endPage > totalPage) {endPage = totalPage;startPage = (endPage - pageCount > 0) ? endPage - pageCount + 1 : 1;}}/*** 获得起始页页码* @return 起始页页码*/public int getStartPage() {return startPage;}/*** 获得终止页页码* @return 终止页页码*/public int getEndPage() {return endPage;}}
package com.hzy.biz;import m.PageBean;import com.hzy.entity.Dept;/*** 部门业务逻辑接口**/public interface DeptService {/*** 创建新的部门* @param department 部门对象* @return 创建成功返回true否则返回false*/public boolean createNewDepartment(Dept department);/*** 删除指定部门* @param id 要删除的部门的编号* @return 删除成功返回true否则返回false*/public boolean deleteDepartment(Integer id);/*** 分页获取顶级部门* @param page 页码* @param size 页码大小* @return 部门对象的分页器对象*/public PageBean<Dept> getTopDeptByPage(int page, int size);}
package com.hzy.biz.impl;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import com.hzy.biz.DeptService;import m.PageBean;import m.QueryResult;import com.hzy.dao.DeptDao;import com.hzy.entity.Dept;@Service@Transactional // 声明式事务的注解public class DeptServiceImpl implements DeptService {@Autowiredprivate DeptDao deptDao;@Overridepublic boolean createNewDepartment(Dept department) {return deptDao.save(department) != null;}@Overridepublic boolean deleteDepartment(Integer id) {return deptDao.deleteById(id);}@Overridepublic PageBean<Dept> getTopDeptByPage(int page, int size) {QueryResult<Dept> queryResult = deptDao.findTopDeptByPage(page, size);PageBean<Dept> pageBean = new PageBean<>(page, size);pageBean.transferQueryResult(queryResult);return pageBean;}}
27、如何在Web项目中配置Spring的IoC容器？
答：如果需要在Web项目中使用Spring的IoC容器，可以在Web项目配置文件web.xml中做出如下配置：
<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>
28、如何在Web项目中配置Spring MVC？
答：要使用Spring MVC需要在Web项目配置文件中配置其前端控制器DispatcherServlet，如下所示：
<web-app><servlet><servlet-name>example</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>example</servlet-name><url-pattern>*.html</url-pattern></servlet-mapping></web-app>
**说明：**上面的配置中使用了*.html的后缀映射，这样做一方面不能够通过URL推断采用了何种服务器端的技术，另一方面可以欺骗搜索引擎，因为搜索引擎不会搜索动态页面，这种做法称为伪静态化。
29、Spring MVC的工作原理是怎样的？
SpringMVC流程
用户发送请求至前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping处理器映射器。
处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
DispatcherServlet调用HandlerAdapter处理器适配器。
HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
Controller执行完成返回ModelAndView。
HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
ViewReslover解析后返回具体View。
DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
DispatcherServlet响应用户。
组件说明：
以下组件通常使用框架提供实现：
DispatcherServlet：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。
HandlerMapping：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
HandlAdapter：通过扩展处理器适配器，支持更多类型的处理器。
ViewResolver：通过扩展视图解析器，支持更多类型的视图解析，例如：jsp、freemarker、pdf、excel等。
组件：
①前端控制器DispatcherServlet（不需要工程师开发）,由框架提供
作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。
②处理器映射器HandlerMapping(不需要工程师开发),由框架提供
作用：根据请求的url查找Handler
HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。
③处理器适配器HandlerAdapter
作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler
通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。
④处理器Handler(需要工程师开发)
注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。
⑤视图解析器View resolver(不需要工程师开发),由框架提供
作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。
⑥视图View(需要工程师开发jsp…)
View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）
核心架构的具体流程步骤如下：
①首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
②DispatcherServlet——>HandlerMapping， HandlerMapping 将会把请求映射为HandlerExecutionChain 对象（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
③DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
④HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；
⑤ModelAndView的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
⑥View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
⑦返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
下边两个组件通常情况下需要开发：
Handler：处理器，即后端控制器用controller表示。View：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。
30、如何在Spring IoC容器中配置数据源？
答：
DBCP配置：
<bean id="dataSource"class="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean><context:property-placeholder location="jdbc.properties"/>
C3P0配置：
<bean id="dataSource"class="com.mchange.boPooledDataSource" destroy-method="close"><property name="driverClass" value="${jdbc.driverClassName}"/><property name="jdbcUrl" value="${jdbc.url}"/><property name="user" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean><context:property-placeholder location="jdbc.properties"/>
31、如何配置配置事务增强？
答：
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/tx/schema/tx/spring-tx.xsd/schema/aop/schema/aop/spring-aop.xsd"><!-- this is the service object that we want to make transactional --><bean id="fooService" class="x.y.service.DefaultFooService"/><!-- the transactional advice --><tx:advice id="txAdvice" transaction-manager="txManager"><!-- the transactional semantics... --><tx:attributes><!-- all methods starting with 'get' are read-only --><tx:method name="get*" read-only="true"/><!-- other methods use the default transaction settings (see below) --><tx:method name="*"/></tx:attributes></tx:advice><!-- ensure that the above transactional advice runs for any executionof an operation defined by the FooService interface --><aop:config><aop:pointcut id="fooServiceOperation" expression="execution(* x.y.service.FooService.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/></aop:config><!-- don't forget the DataSource --><bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/><property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/><property name="username" value="scott"/><property name="password" value="tiger"/></bean><!-- similarly, don't forget the PlatformTransactionManager --><bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><!-- other <bean/> definitions here --></beans>
32、选择使用Spring框架的原因（Spring框架为企业级开发带来的好处有哪些）？
答：可以从以下几个方面作答：
- 非侵入式：支持基于POJO的编程模式，不强制性的要求实现Spring框架中的接口或继承Spring框架中的类。
- IoC容器：IoC容器帮助应用程序管理对象以及对象之间的依赖关系，对象之间的依赖关系如果发生了改变只需要修改配置文件而不是修改代码，因为代码的修改可能意味着项目的重新构建和完整的回归测试。有了IoC容器，程序员再也不需要自己编写工厂、单例，这一点特别符合Spring的精神"不要重复的发明轮子"。
- AOP（面向切面编程）：将所有的横切关注功能封装到切面（aspect）中，通过配置的方式将横切关注功能动态添加到目标代码上，进一步实现了业务逻辑和系统服务之间的分离。另一方面，有了AOP程序员可以省去很多自己写代理类的工作。
- MVC：Spring的MVC框架是非常优秀的，从各个方面都可以甩Struts 2几条街，为Web表示层提供了更好的解决方案。
- 事务管理：Spring以宽广的胸怀接纳多种持久层技术，并且为其提供了声明式的事务管理，在不需要任何一行代码的情况下就能够完成事务管理。
- 其他：选择Spring框架的原因还远不止于此，Spring为Java企业级开发提供了一站式选择，你可以在需要的时候使用它的部分和全部，更重要的是，你甚至可以在感觉不到Spring存在的情况下，在你的项目中使用Spring提供的各种优秀的功能。
33、Spring IoC容器配置Bean的方式？
答：
- 基于XML文件进行配置。
- 基于注解进行配置。
- 基于Java程序进行配置（Spring 3+）
package com.hzy.bean;import org.springframework.beans.factory.annotation.Autowired;import org.ponent;@Componentpublic class Person {private String name;private int age;@Autowiredprivate Car car;public Person(String name, int age) {this.name = name;this.age = age;}public void setCar(Car car) {this.car = car;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";}}
package com.hzy.bean;import org.ponent;@Componentpublic class Car {private String brand;private int maxSpeed;public Car(String brand, int maxSpeed) {this.brand = brand;this.maxSpeed = maxSpeed;}@Overridepublic String toString() {return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";}}
package com.hzy.config;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import com.hzy.bean.Car;import com.hzy.bean.Person;@Configurationpublic class AppConfig {@Beanpublic Car car() {return new Car("Benz", 320);}@Beanpublic Person person() {return new Person("hzy", 34);}}
package com.hzy.test;import org.springframework.context.ConfigurableApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import com.hzy.bean.Person;import com.hzy.config.AppConfig;class Test {public static void main(String[] args) {// TWR (Java 7+)try(ConfigurableApplicationContext factory = new AnnotationConfigApplicationContext(AppConfig.class)) {Person person = factory.getBean(Person.class);System.out.println(person);}}}
34、阐述Spring框架中Bean的生命周期？
答：
① Spring IoC容器找到关于Bean的定义并实例化该Bean。
② Spring IoC容器对Bean进行依赖注入。
③ 如果Bean实现了BeanNameAware接口，则将该Bean的id传给setBeanName方法。
④ 如果Bean实现了BeanFactoryAware接口，则将BeanFactory对象传给setBeanFactory方法。
⑤ 如果Bean实现了BeanPostProcessor接口，则调用其postProcessBeforeInitialization方法。
⑥ 如果Bean实现了InitializingBean接口，则调用其afterPropertySet方法。
⑦ 如果有和Bean关联的BeanPostProcessors对象，则这些对象的postProcessAfterInitialization方法被调用。
⑧ 当销毁Bean实例时，如果Bean实现了DisposableBean接口，则调用其destroy方法。
35、依赖注入时如何注入集合属性？
答：可以在定义Bean属性时，通过 / /
36、Spring中的自动装配有哪些限制？
答：
- 如果使用了构造器注入或者setter注入，那么将覆盖自动装配的依赖关系。
- 基本数据类型的值、字符串字面量、类字面量无法使用自动装配来注入。
- 优先考虑使用显式的装配来进行更精确的依赖注入而不是使用自动装配。
37、在Web项目中如何获得Spring的IoC容器？
答：
WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
38、大型网站在架构上应当考虑哪些问题？
答：
分层：分层是处理任何复杂系统最常见的手段之一，将系统横向切分成若干个层面，每个层面只承担单一的职责，然后通过下层为上层提供的基础设施和服务以及上层对下层的调用来形成一个完整的复杂的系统。计算机网络的开放系统互联参考模型（OSI/RM）和Internet的TCP/IP模型都是分层结构，大型网站的软件系统也可以使用分层的理念将其分为持久层（提供数据存储和访问服务）、业务层（处理业务逻辑，系统中最核心的部分）和表示层（系统交互、视图展示）。需要指出的是：（1）分层是逻辑上的划分，在物理上可以位于同一设备上也可以在不同的设备上部署不同的功能模块，这样可以使用更多的计算资源来应对用户的并发访问；（2）层与层之间应当有清晰的边界，这样分层才有意义，才更利于软件的开发和维护。分割：分割是对软件的纵向切分。我们可以将大型网站的不同功能和服务分割开，形成高内聚低耦合的功能模块（单元）。在设计初期可以做一个粗粒度的分割，将网站分割为若干个功能模块，后期还可以进一步对每个模块进行细粒度的分割，这样一方面有助于软件的开发和维护，另一方面有助于分布式的部署，提供网站的并发处理能力和功能的扩展。分布式：除了上面提到的内容，网站的静态资源（JavaScript、CSS、图片等）也可以采用独立分布式部署并采用独立的域名，这样可以减轻应用服务器的负载压力，也使得浏览器对资源的加载更快。数据的存取也应该是分布式的，传统的商业级关系型数据库产品基本上都支持分布式部署，而新生的NoSQL产品几乎都是分布式的。当然，网站后台的业务处理也要使用分布式技术，例如查询索引的构建、数据分析等，这些业务计算规模庞大，可以使用Hadoop以及MapReduce分布式计算框架来处理。集群：集群使得有更多的服务器提供相同的服务，可以更好的提供对并发的支持。缓存：所谓缓存就是用空间换取时间的技术，将数据尽可能放在距离计算最近的位置。使用缓存是网站优化的第一定律。我们通常说的CDN、反向代理、热点数据都是对缓存技术的使用。异步：异步是实现软件实体之间解耦合的又一重要手段。异步架构是典型的生产者消费者模式，二者之间没有直接的调用关系，只要保持数据结构不变，彼此功能实现可以随意变化而不互相影响，这对网站的扩展非常有利。使用异步处理还可以提高系统可用性，加快网站的响应速度（用Ajax加载数据就是一种异步技术），同时还可以起到削峰作用（应对瞬时高并发）。"；能推迟处理的都要推迟处理"是网站优化的第二定律，而异步是践行网站优化第二定律的重要手段。冗余：各种服务器都要提供相应的冗余服务器以便在某台或某些服务器宕机时还能保证网站可以正常工作，同时也提供了灾难恢复的可能性。冗余是网站高可用性的重要保证。
39、你用过的网站前端优化的技术有哪些？
答：
① 浏览器访问优化：
- 减少HTTP请求数量：合并CSS、合并JavaScript、合并图片（CSS Sprite）
- 使用浏览器缓存：通过设置HTTP响应头中的Cache-Control和Expires属性，将CSS、JavaScript、图片等在浏览器中缓存，当这些静态资源需要更新时，可以更新HTML文件中的引用来让浏览器重新请求新的资源
- 启用压缩
- CSS前置，JavaScript后置
- 减少Cookie传输
② CDN加速：CDN（Content Distribute Network）的本质仍然是缓存，将数据缓存在离用户最近的地方，CDN通常部署在网络运营商的机房，不仅可以提升响应速度，还可以减少应用服务器的压力。当然，CDN缓存的通常都是静态资源。
③ 反向代理：反向代理相当于应用服务器的一个门面，可以保护网站的安全性，也可以实现负载均衡的功能，当然最重要的是它缓存了用户访问的热点资源，可以直接从反向代理将某些内容返回给用户浏览器。
40、你使用过的应用服务器优化技术有哪些？
答：
① 分布式缓存：缓存的本质就是内存中的哈希表，如果设计一个优质的哈希函数，那么理论上哈希表读写的渐近时间复杂度为O(1)。缓存主要用来存放那些读写比很高、变化很少的数据，这样应用程序读取数据时先到缓存中读取，如果没有或者数据已经失效再去访问数据库或文件系统，并根据拟定的规则将数据写入缓存。对网站数据的访问也符合二八定律（Pareto分布，幂律分布），即80%的访问都集中在20%的数据上，如果能够将这20%的数据缓存起来，那么系统的性能将得到显著的改善。当然，使用缓存需要解决以下几个问题：
- 频繁修改的数据；
- 数据不一致与脏读；
- 缓存雪崩（可以采用分布式缓存服务器集群加以解决，memcached是广泛采用的解决方案）；
- 缓存预热；
- 缓存穿透（恶意持续请求不存在的数据）。
② 异步操作：可以使用消息队列将调用异步化，通过异步处理将短时间高并发产生的事件消息存储在消息队列中，从而起到削峰作用。电商网站在进行促销活动时，可以将用户的订单请求存入消息队列，这样可以抵御大量的并发订单请求对系统和数据库的冲击。目前，绝大多数的电商网站即便不进行促销活动，订单系统都采用了消息队列来处理。
③ 使用集群。
④ 代码优化：
- 多线程：基于Java的Web开发基本上都通过多线程的方式响应用户的并发请求，使用多线程技术在编程上要解决线程安全问题，主要可以考虑以下几个方面：A. 将对象设计为无状态对象（这和面向对象的编程观点是矛盾的，在面向对象的世界中被视为不良设计），这样就不会存在并发访问时对象状态不一致的问题。B. 在方法内部创建对象，这样对象由进入方法的线程创建，不会出现多个线程访问同一对象的问题。使用ThreadLocal将对象与线程绑定也是很好的做法，这一点在前面已经探讨过了。C. 对资源进行并发访问时应当使用合理的锁机制。
- 非阻塞I/O： 使用单线程和非阻塞I/O是目前公认的比多线程的方式更能充分发挥服务器性能的应用模式，基于Node.js构建的服务器就采用了这样的方式。Java在JDK 1.4中就引入了NIO（Non-blocking I/O）,在Servlet 3规范中又引入了异步Servlet的概念，这些都为在服务器端采用非阻塞I/O提供了必要的基础。
- 资源复用：资源复用主要有两种方式，一是单例，二是对象池，我们使用的数据库连接池、线程池都是对象池化技术，这是典型的用空间换取时间的策略，另一方面也实现对资源的复用，从而避免了不必要的创建和释放资源所带来的开销。
41、什么是XSS攻击？什么是SQL注入攻击？什么是CSRF攻击？
答：
- XSS（Cross Site Script，跨站脚本攻击）是向网页中注入恶意脚本在用户浏览网页时在用户浏览器中执行恶意脚本的攻击方式。跨站脚本攻击分有两种形式：反射型攻击（诱使用户点击一个嵌入恶意脚本的链接以达到攻击的目标，目前有很多攻击者利用论坛、微博发布含有恶意脚本的URL就属于这种方式）和持久型攻击（将恶意脚本提交到被攻击网站的数据库中，用户浏览网页时，恶意脚本从数据库中被加载到页面执行，QQ邮箱的早期版本就曾经被利用作为持久型跨站脚本攻击的平台）。XSS虽然不是什么新鲜玩意，但是攻击的手法却不断翻新，防范XSS主要有两方面：消毒（对危险字符进行转义）和HttpOnly（防范XSS攻击者窃取Cookie数据）。
- SQL注入攻击是注入攻击最常见的形式（此外还有OS注入攻击（Struts 2的高危漏洞就是通过OGNL实施OS注入攻击导致的）），当服务器使用请求参数构造SQL语句时，恶意的SQL被嵌入到SQL中交给数据库执行。SQL注入攻击需要攻击者对数据库结构有所了解才能进行，攻击者想要获得表结构有多种方式：（1）如果使用开源系统搭建网站，数据库结构也是公开的（目前有很多现成的系统可以直接搭建论坛，电商网站，虽然方便快捷但是风险是必须要认真评估的）；（2）错误回显（如果将服务器的错误信息直接显示在页面上，攻击者可以通过非法参数引发页面错误从而通过错误信息了解数据库结构，Web应用应当设置友好的错误页，一方面符合最小惊讶原则，一方面屏蔽掉可能给系统带来危险的错误回显信息）；（3）盲注。防范SQL注入攻击也可以采用消毒的方式，通过正则表达式对请求参数进行验证，此外，参数绑定也是很好的手段，这样恶意的SQL会被当做SQL的参数而不是命令被执行，JDBC中的PreparedStatement就是支持参数绑定的语句对象，从性能和安全性上都明显优于Statement。
- CSRF攻击（Cross Site Request Forgery，跨站请求伪造）是攻击者通过跨站请求，以合法的用户身份进行非法操作（如转账或发帖等）。CSRF的原理是利用浏览器的Cookie或服务器的Session，盗取用户身份，其原理如下图所示。防范CSRF的主要手段是识别请求者的身份，主要有以下几种方式：（1）在表单中添加令牌（token）；（2）验证码；（3）检查请求头中的Referer（前面提到防图片盗链接也是用的这种方式）。令牌和验证都具有一次消费性的特征，因此在原理上一致的，但是验证码是一种糟糕的用户体验，不是必要的情况下不要轻易使用验证码，目前很多网站的做法是如果在短时间内多次提交一个表单未获得成功后才要求提供验证码，这样会获得较好的用户体验。
**补充：**防火墙的架设是Web安全的重要保障，ModSecurity是开源的Web防火墙中的佼佼者。企业级防火墙的架设应当有两级防火墙，Web服务器和部分应用服务器可以架设在两级防火墙之间的DMZ，而数据和资源服务器应当架设在第二级防火墙之后。
42. 什么是领域模型(domain model)？贫血模型(anaemic domain model)和充血模型(rich domain model)有什么区别？
答：领域模型是领域内的概念类或现实世界中对象的可视化表示，又称为概念模型或分析对象模型，它专注于分析问题领域本身，发掘重要的业务领域概念，并建立业务领域概念之间的关系。贫血模型是指使用的领域对象中只有setter和getter方法（POJO），所有的业务逻辑都不包含在领域对象中而是放在业务逻辑层。有人将我们这里说的贫血模型进一步划分成失血模型（领域对象完全没有业务逻辑）和贫血模型（领域对象有少量的业务逻辑），我们这里就不对此加以区分了。充血模型将大多数业务逻辑和持久化放在领域对象中，业务逻辑（业务门面）只是完成对业务逻辑的封装、事务和权限等的处理。下面两张图分别展示了贫血模型和充血模型的分层架构。
贫血模型
充血模型
贫血模型下组织领域逻辑通常使用事务脚本模式，让每个过程对应用户可能要做的一个动作，每个动作由一个过程来驱动。也就是说在设计业务逻辑接口的时候，每个方法对应着用户的一个操作，这种模式有以下几个有点：
- 它是一个大多数开发者都能够理解的简单过程模型（适合国内的绝大多数开发者）。
- 它能够与一个使用行数据入口或表数据入口的简单数据访问层很好的协作。
- 事务边界的显而易见，一个事务开始于脚本的开始，终止于脚本的结束，很容易通过代理（或切面）实现声明式事务。
然而，事务脚本模式的缺点也是很多的，随着领域逻辑复杂性的增加，系统的复杂性将迅速增加，程序结构将变得极度混乱。开源中国社区上有一篇很好的译文《贫血领域模型是如何导致糟糕的软件产生》对这个问题做了比较细致的阐述。
43. 谈一谈测试驱动开发（TDD）的好处以及你的理解。
答：TDD是指在编写真正的功能实现代码之前先写测试代码，然后根据需要重构实现代码。在JUnit的作者Kent Beck的大作《测试驱动开发：实战与模式解析》（Test-Driven Development: by Example）一书中有这么一段内容：“消除恐惧和不确定性是编写测试驱动代码的重要原因”。因为编写代码时的恐惧会让你小心试探，让你回避沟通，让你羞于得到反馈，让你变得焦躁不安，而TDD是消除恐惧、让Java开发者更加自信更加乐于沟通的重要手段。TDD会带来的好处可能不会马上呈现，但是你在某个时候一定会发现，这些好处包括：
- 更清晰的代码 — 只写需要的代码
- 更好的设计
- 更出色的灵活性 — 鼓励程序员面向接口编程
- 更快速的反馈 — 不会到系统上线时才知道bug的存在
**补充：**敏捷软件开发的概念已经有很多年了，而且也部分的改变了软件开发这个行业，TDD也是敏捷开发所倡导的。
TDD可以在多个层级上应用，包括单元测试（测试一个类中的代码）、集成测试（测试类之间的交互）、系统测试（测试运行的系统）和系统集成测试（测试运行的系统包括使用的第三方组件）。TDD的实施步骤是：红（失败测试）- 绿（通过测试） - 重构。在使用TDD开发时，经常会遇到需要被测对象需要依赖其他子系统的情况，但是你希望将测试代码跟依赖项隔离，以保证测试代码仅仅针对当前被测对象或方法展开，这时候你需要的是测试替身。测试替身可以分为四类：
- 虚设替身：只传递但是不会使用到的对象，一般用于填充方法的参数列表
- 存根替身：总是返回相同的预设响应，其中可能包括一些虚设状态
- 伪装替身：可以取代真实版本的可用版本（比真实版本还是会差很多）
- 模拟替身：可以表示一系列期望值的对象，并且可以提供预设响应
Java世界中实现模拟替身的第三方工具非常多，包括EasyMock、Mockito、jMock等。
