基于泛型DAO的Facade设计模式.
在做管理系统时。通常基于Facade模式的系统持久化层要写许多Dao。这些dao 里面的方法又是重复的，那么有没有什么好的方法来统一利用一个公共的Dao。
答案是可以的。这里我们接触到JDK5.0里面的一个新特性：泛型。
关于泛型的含义我这里就不再解释了。
下面我们以一个对用户管理和新闻管理的来示范。
首先是2个POJO。我这里只列出User POJO。
（基于注释的Pojo）
Java代码
1.
2.package com.oa;
3.
4.import javax.persistence.Column;
5.import javax.persistence.Entity;
6.import javax.persistence.GeneratedValue;
7.import javax.persistence.GenerationType;
8.import javax.persistence.Id;
9.import javax.persistence.Table;
10.
11.@Entity
12.@Table(name = "tb_user")
13.public class User {
14.
15. @Id
16. @GeneratedValue(strategy = GenerationType.IDENTITY)
17. private int id;
18.
19. @Column(name = "username", length = 15)
20. private String username;
21.
22. @Column(name = "password", length = 15)
23. private String password;
24.
25. public int getId() {
26. return id;
27. }
28.
29. public void setId(int id) {
30. this.id = id;
31. }
33. public String getUsername() {
34. return username;
35. }
36.
37. public void setUsername(String username) {
38. https://www.360docs.net/doc/f412229393.html,ername = username;
39. }
40.
41. public String getPassword() {
42. return password;
43. }
44.
45. public void setPassword(String password) {
46. this.password = password;
47. }
48.
49.}
50.
51.
如果按照常规的Facade模式来设计，我们的思路是：
先创建一个UserDao的接口。
Java代码
1.package com.oa.dao;
2.
3.import java.util.List;
4.
5.import https://www.360docs.net/doc/f412229393.html,er;
6.
7.public interface UserDao {
8. public void save(User user);
9.
10. public void delete(int id);
11.
12. public void update(User user);
13.
14. public List
15.
16. public User get(int id);
17.
18.}
20.
然后实现这个接口：UserDaoImpl
Java代码
1.package com.oa.dao.impl;
2.
3.import java.util.List;
4.
5.import org.springframework.context.annotation.Scope;
6.import org.springframework.stereotype.Repository;
7.
8.import https://www.360docs.net/doc/f412229393.html,er;
9.import com.oa.dao.MyHibernateDaoSupport;
10.import https://www.360docs.net/doc/f412229393.html,erDao;
11.
12.
13.
14./**
15. * 从Spring 2.0开始，引入了@Repository注解，
16. * 用它来标记充当储存库(又称 Data Access Object或DAO)角色或典
型的类
17. */
18.
19.
20./**
21. * Spring 2.5引入了更多典型化注解
(stereotype annotations)： @Component、@Service
和 @Controller。
22. * @Component是所有受Spring管理组件的通用形式；而@Repository、
@Service和 @Controller则是@Component的细化，
23. * 用来表示更具体的用例(例如，分别对应了持久化
层、服务层和表现层)。
24. */
25.//@Scope("singlton")
26.@Repository("userDao")//声明此类为数据持久层的类
27.public class UserDaoImpl extends MyHibernateDaoSupport implemen
ts UserDao {
28.
29. public void delete(int id) {
30. super.getHibernateTemplate().delete(
31. super.getHibernateTemplate().load(User.class, i
d));
32.
33. }
34.
35. public User get(int id) {
36.
37. return (User) super.getHibernateTemplate().get("from U
ser", id);
38. }
39.
40. @SuppressWarnings("unchecked")
41. public List
42. return super.getHibernateTemplate().find("from User");
43.
44. }
45.
46. public void save(User user) {
47. super.getHibernateTemplate().save(user);
48.
49. }
50.
51. public void update(User user) {
52. super.getHibernateTemplate().update(user);
53.
54. }
55.
56.}
57.
58.
持久化层完毕。
接下来的是事务层
先创建一个UserService的接口。
Java代码
1.
2.package com.oa.service;
3.
4.import https://www.360docs.net/doc/f412229393.html,er;
5.
6.public interface UserService {
7.
8. public void save(User user);
9.
10. public void update(User user);
11.
12.}
13.
然后实现这个接口：UserServiceImpl。
在UserServiceImpl里引用UserDao来实现业务逻辑。
Java代码
1.package com.oa.service.impl;
2.
3.import https://www.360docs.net/doc/f412229393.html,er;
4.import https://www.360docs.net/doc/f412229393.html,erService;
5.import https://www.360docs.net/doc/f412229393.html,erDao;
6.
7.
8.import java.util.List;
9.
10.import org.springframework.beans.factory.annotation.Autowired;
11.import org.springframework.stereotype.Service;
12.
13.
14.
15./**
16. * 声明此类为业务逻辑层的类
17. * 默认bean名称生成器会返回小写开头的非限定(non-qualified)类
名
18. * @Service
19. * userServiceImpl
20. */
21.@Service("userService")
22.public class UserServiceImpl implements UserService {
23.
24.
25. /**
26. * @Autowired
27. *
28. * @Autowired 注解可以用于"传统的"setter 方法，如下例：
29. * public void setUserDao(UserDAO userDao)
30. {
31. https://www.360docs.net/doc/f412229393.html,erDao = userDao;
32. }
33. */
34.
35. /**
36. * @Resource有一个'name'属性，缺省时，Spring 将这个值解释为
要注射的 bean 的名字。
37. * @Resource(name="userDao")
38. */
39. @Autowired // or @Resource(name="userDao")
40. private UserDao userDao;
41.
42. public void save(User user) {
43. userDao.save(user);
44.
45. }
46.
47. public void update(User user) {
48. userDao.update(user);
49.
50. }
51.
52.}
53.
54.
按照上面的模式：新闻管理也这么写一遍。
重复的工作使得我们觉得好烦。
这个时候是泛型出场的时候了。
基于Facade的设计模式，dao和service还是要的。这里我们就要设计一个公共的Dao.. 我们称之为：GenericDao
Java代码
1.package com.oa.dao;
2.
3.import java.io.Serializable;
4.import java.util.*;
5.
6./**
7. * *
8. *
9. * @param
10. * 泛型，指实体类 type
11. * @param
12. * 泛型，指实体类主键的数据类型，如Integer,Long
13. */
14.public interface GenericDao
15.
16. /**
17. * 保存指定实体类
18. *
19. * @param entityobj
20. * 实体类
21. */
22. public void save(T entity);
23.
24.
25. /**
26. * 删除指定实体
27. *
28. * @param entityobj
29. * 实体类
30. */
31. public void delete(T entity);
32.
33.
34. /** *
35. * 删除实体
36. * @param entityClass 实体类名
37. * @param id 实体的ID
38. */
39. public void deleteById(Class
40.
41.
42. /**
43. * 更新或保存指定实体
44. *
45. * @param entity 实体类
46. */
47. public void saveorupdate(T entity);
48.
49.
50. /** *
51. * 更新实体
52. * 可用于添加、修改、删除操作
53. * @param hql 更新的HQL语句
54. * @param params 参数,可有项目或多项目,代替Hql中的"?"号
55. */
56. public void update(final String hql,final Object[] params);
57.
58.
59.
60. /**
61. * 模糊查询指定条件对象集合
62. * 用法：可以实例化一个空的T对象，需要查询某个字段，就set
该字段的条件然后调用本方法
63. * 缺点：目前测试貌似只能支持String的模糊查询，虽然有办法重
写，但没必要，其他用HQL
64. *
65. * @param entity
66. * 条件实体
67. * @return 结合
68. */
69. public List
70.
71.
72. /**
73. * 获取所有实体集合
74. *
75. * @param entityClass
76. * 实体
77. * @return 集合
78. */
79. public List
80.
81. public List
ct[] params,int start, int limit);
82. /**
83. * 查找指定PK实体类对象
84. *
85. * @param entityClass
86. * 实体Class
87. * @param id
88. * 实体PK
89. * @return 实体对象
90. */
91. public T findById(Class
92.
93. /** *
94. * 按HQL条件查询列表
95. * @param hql 查询语句,支持连接查询和多条件查询
96. * @param params 参数数组,代替hql中的"?"号
97. * @return 结果集List
98. */
99.
100. public List
101.
102. /**
103. * 查找指定属性的实体集合
104. *
105. * @param entityClass
106. * 实体
107. * @param propertyName
108. * 属性名
109. * @param value
110. * 条件
111. * @return 实体集合
112. */
113. public List
114.
115.
116. /**
117. * 查询指定HQL语句的分页数据集合
118. *
119. * @param hsql
120. * HQL语句
121. * @param start
122. * 开始记录号
123. * @param limit
124. * 最大记录号
125. * @return 分页数据集合
126. * @throws Exception
127. * 抛出异常
128. */
129. public List
130.
131.
132.
133. /**
134. * 获得总记录数
135. */
136. public T getTotalCount(Class
137.
138. public T getPageCount(String hql,Object[] params);
139.
140.}
141.
看到，我们不再是具体的User ， News
。。而是用 T 来取代实体。
因为我这个是基于注解的，所以附上MyHibernateDaoSupport的代码。
Java代码
1.package com.oa.dao;
2.
3.import javax.annotation.Resource;
4.import org.hibernate.SessionFactory;
5.import org.springframework.orm.hibernate3.support.HibernateDaoS
upport;
6.
7./**
8. * 我们之所以要改写
9. * HibernateDaoSupport，是因我为，我们要为DAO层的类注入
SessionFactory这个属性。
10. * 以后，我们开发的DAO类，就可以直接重用这个
MyHibernateDaoSupport了。
11. * 其实，这样做是相当于配置文件方式的代码：
12. *
13. * 14. * name="sessionFactory" ref="sessionFactory"/> 15. * 16. * 17. * @author Administrator 18. * 19. */ 20.public class MyHibernateDaoSupport extends HibernateDaoSupport { 21. 22. @Resource(name="sessionFactory") //为父类 HibernateDaoSupport注入sessionFactory的值 23. public void setSuperSessionFactory(SessionFactory sessionFa ctory){ 24. super.setSessionFactory(sessionFactory); 25. } 26. 27. 28.} 29. 30. 到现在位置genericdao的接口有了，也就是我们要做什么。。现在就是实现它，就是怎么做。 GenericDaoImpl 代码： Java代码 1.package com.oa.dao.impl; 2. 3.import java.io.Serializable; 4.import java.util.List; 5. 6.import org.hibernate.Query; 7.import org.springframework.stereotype.Repository; 8. 9.import com.oa.dao.GenericDao; 10.import com.oa.dao.MyHibernateDaoSupport; 11.@SuppressWarnings("unchecked") 12.@Repository("genericDao") //声明此类为数据持久层的类 13.public class GenericDaoImpl 14. MyHibernateDaoSupport imple ments GenericDao 15. 16. public void delete(T entity) { 17. super.getHibernateTemplate().delete(entity); 18. } 19. 20. 21. public void deleteById(Class entityClass, PK id) { 22. super.getHibernateTemplate().delete(findById(entityClas s, id)); 23. 24. } 25. 26. public void save(T entity) { 27. super.getHibernateTemplate().save(entity); 28. 29. } 30. 31. public void saveorupdate(T entity) { 32. super.getHibernateTemplate().saveOrUpdate(entity); 33. 34. } 35. 36. public void update(String hql, Object[] params) { 37. Query query = super.getSession().createQuery(hql); 38. for(int i=0; i 39. query.setParameter(i, params[i]); 40. } 41. query.executeUpdate(); 42. } 43. 44. 45. public List 46. 47. return super.getHibernateTemplate().loadAll(entityClass ); 48. } 49. 50. public List t[] params,int start, int limit) { 51. Query query = super.getSession().createQuery(hql); 52. if(params!=null&¶ms.length>0){ 53. for(int i = 0;i 54. query.setParameter(i, params[i]); 55. } 56. } 57. if(start!=0&&limit!=0){ 58. query.setFirstResult(start).setMaxResults(limit); 59. } 60. return query.list(); 61. } 62. 63. public List 64. return super.getHibernateTemplate().findByExample(entit y); 65. } 66. 67. public List 68. Query query = super.getSession().createQuery(hql); 69. if(null!= params && params.length>0){ 70. for(int i = 0; i 71. query.setParameter(i, params[i]); 72. } 73. } 74. return query.list(); 75. } 76. 77. public T findById(Class entityClass, PK id) { 78. return (T)super.getHibernateTemplate().get(entityClass, id); 79. } 80. 81. public List pertyName,Object value) { 82. String queryString = "from "+entityClass.getName()+ " a s model where model." + propertyName + "=?"; 83. return super.getHibernateTemplate().find(queryString, v alue); 84. } 85. 86. 87. 88. //分页使用 89. public List t limit) { 90. Query query=super.getSession().createQuery("select o from "+entityClass.getName()+" o"); 91. query.setFirstResult(start).setMaxResults(limit); 92. return query.list(); 93. } 94. 95. 96. public T getTotalCount(Class entityClass) { 97. 98. return (T)super.getSession().createQuery("select count( o) from "+entityClass.getName()+" o").uniqueResult(); 99. } 100. 101. public T getPageCount(String hql, Object[] params) { 102. Query query = super.getSession().createQuery(hql); 103. if(null!= params && params.length>0){ 104. for(int i = 0; i 105. query.setParameter(i, params[i]); 106. } 107. } 108. return (T)query.list(); 109. } 110. 111. 112. 113.} 至此泛型就告一个段落。 接下来日子就好过了。 我们不是有user news 等等一系列的curd管理。 以User为例子； 定义一个user的接口， UserDao.Java Java代码 1.package com.oa.dao; 2. 3.import https://www.360docs.net/doc/f412229393.html,er; 4. 5.public interface UserDao extends GenericDao 6. 7.public int login（User user）; 8.//其他的方法的 9.} 10. 11. 12.然后就是实现它 UserDaoImpl 13. 14.package com.oa.dao.impl; 15. 16. 17. 18.import https://www.360docs.net/doc/f412229393.html,er; 19.import https://www.360docs.net/doc/f412229393.html,erDao; 20. 21.public class UserDaoImpl extends GenericDaoImpl implements UserDao { 22. 23. public int login（User user）{ 24.//登陆判断的方法 25. 26.return XX; 27.}; 28. 29. 30.//其他的方法的实现 31. 32. 33.} 34. 35. 持久化层就是这么多了。 下面进入业务逻辑层，依然是先定义一个接口。 Java代码 1.package com.oa.service; 2. 3.import https://www.360docs.net/doc/f412229393.html,er; 4. 5.public interface UserService { 6. 7. public void save(User user); 8. 9. public void update(User user); 10. 11. public int login（User user）； 12. 13.//其他的方法 14. 15.} 16. 接下来是实现 Java代码 1.package com.oa.service.impl; 2. 3.import https://www.360docs.net/doc/f412229393.html,er; 4.import com.oa.dao. UserDao; 5.import com.oa.service.TestUserService; 6. 7.public class UserService implements UserService { 8. 9. private UserDao UserDao; 10. public void save(User user) { 11. UserDao.save(user); 12. 13. } 14. 15. public void updasaveorupdatete(User user) { 16. UserDao.saveorupdate(user); 17. 18. } 19. 20. public int login(User user) { 21. return UserDao.login(user); 22. 23. } 24. 25.//其他的方法。。。。 26. 27.} 28. 29. Ok。。到现在我们就利用泛型dao来设计就完毕了 两者相对比，发现dao层的代码可以复用，少了不少。对于大型管理系统，效果更明显。 Junit Test方法我这里就不提供了。 1.Factory Method模式和Abstract Factory模式的区别在哪？一般哪些情况下适合用前者，哪些情况下适合用后者？ 1）不同之处主要在于： 应用环境不同：FM中创建者的职责并不仅限于创建对象，而AF通常只有创建对象这一职责。 实现方式不同：FM是实现继承，抽象类实现大部分操作，通常仅将对象的创建工作延迟到子类来完成；AF是接口继承，抽象类通常不实现任何功能，仅仅定义一系列接口，子类实现抽象类定义的接口。Factory Method模式与Abstract Factory模式的区别 2） 在这些情况下使用Factory Method: 当一个类不知道它所必须创建的对象的类的时候； 当一个类希望由它的子类来指定它所创建的对象的时候； 当类将创建对象的职责委托给多个帮助子类中的某一个，并且程序员希望将哪一个帮助子类是代理者这一信息局部化的时候。 在这些情况下使用Abstract Factory: 一个系统要独立于它的产品的创建、组合和表示时。 一个系统要由多个产品系列中的一个来配置时。 当你要强调一系列相关的产品对象的设计以便进行联合使用时。 当你提供一个产品类库，而只想显示它们的接口而不是实现时。 2.解释Java中clone()方法和https://www.360docs.net/doc/f412229393.html,ng.Cloneable接口的关系，如果想要实现深拷贝可以有哪些方法？ 1）cloneable接口中的一个方法是clone方法，实现cloneable接口必须实现接口中包含的clone 方法。如果在没有实现Cloneable 接口的实例上调用Object的clone方法，则会导致抛出CloneNotSupportedException 异常。 2）实现深拷贝的方法： 实现ICloneable接口，自定义拷贝功能； 通过反射实现； 序列化/反序列化类实现。 3. https://www.360docs.net/doc/f412229393.html,ng.Math类和https://www.360docs.net/doc/f412229393.html,ng.StrictMath类是否是单例模式？ 都不是单例模式。 原因： 这两个类均有一个私有的构造函数。但是这仅仅是单例模式的必要条件，而不是充分条件。根据单例模式的三个特性可以看出，无论是Math 还是StrictMath 都没有为外界提供任何自身的实例。实际上，这两个类都是被设计来提供静态工厂方法和常量的，因此从来就不需要它们的实例，这才是它们的构造子是私有的原因。 4. 如何保证单例模式中单例的线程安全？请列举两种或以上方法。 1）将类的构造函数设计为私有的，并提供一个public static方法，返回这个对象的指针。若这个函数返回的是null，则可以创建一个对象；否则不能创建新的对象。另外，由于多线 1.1习题1解答 1. （1）机器语言是计算机直接理解执行的语言，由一系列（二进制）指令组成，其助记符构成了汇编语言；接近人的自然语言习惯的程序设计语言为高级语言。 （2）结构化程序设计方法主要内容有：自顶向下，逐步求精；面向对象方法将现实世界中的客观事物描述成具有属性和行为的对象，抽象出共同属性和行为，形成类。 （3）C++程序开发通常要经过5个阶段，包括：编辑，编译，连接，运行，调试。首先是编辑阶段，任务是编辑源程序，C++源程序文件通常带有.c p p扩展名。接着，使用编译器对源程序进行编译，将源程序翻译为机器语言代码（目标代码），过程分为词法分析、语法分析、代码生成3个步骤。 在此之前，预编译器会自动执行源程序中的预处理指令，完成将其他源程序文件包括到要编译的文件中，以及执行各种文字替换等。 连接器的功能就是将目标代码同缺失函数的代码连接起来，将这个“漏洞”补上，生成可执行文件。程序运行时，可执行文件由操作系统装入内存，然后CPU从内存中取出程序执行。若程序运行进程中出现了错误，还在需要对程序进行调试。 （4）对象与对象之间通过消息进行相互通信。 （5）类是具有相同属性和行为的一组对象的抽象；任何一个对象都是某个类的一个实例。（6）多态性是指在一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。 （7）面向对象的软件开发过程主要包括面向对象的方法分析、面向对象的设计、面向对象的编程、面向对象的测试和面向对象的维护。 （8）泛型程序设计是指在程序设计时，将数据类型参数化，编写具有通用性和可重用的程 序。 （9）#include Java中常见设计模式面试题 一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 1.请列举出在JDK中几个常用的设计模式？ 单例模式（Singleton pattern）用于Runtime，Calendar和其他的一些类中。工厂模式（Factory pattern）被用于各种不可变的类如Boolean，像Boolean.valueOf，观察者模式（Observer pattern）被用于 Swing 和很多的事件监听中。装饰器设计模式（Decorator design pattern）被用于多个 Java IO 类中。 2.什么是设计模式？你是否在你的代码里面使用过任何设计模式？ 设计模式是世界上各种各样程序员用来解决特定设计问题的尝试和测试的方法。设计模式是代码可用性的延伸 3.Java 中什么叫单例设计模式？请用Java 写出线程安全的单例模式 单例模式重点在于在整个系统上共享一些创建时较耗资源的对象。整个应用中只维护一个特定类实例，它被所有组件共同使用。https://www.360docs.net/doc/f412229393.html,ng.Runtime是单例模式的经典例子。从 Java 5 开始你可以使用枚举（enum）来实现线程安全的单例。 4.在 Java 中，什么叫观察者设计模式（observer design pattern）？ 《面向对象程序设计》习题 第8章泛型编程 一、选择题（共40分，每题2分） 二、填空题（共20分，每空2分） 1. 逻辑数据类型 2. 函数类 3. 函数模板类模板 4．函数类型形参类型 5．2 6. 尖括号 三、下列程序有2个错，找出并修改（共6分） 错1：public: A(T a, b) // A(T a,T b) {x=a,y=b;s=x+y;} 错2： int main() { A add(10,100); // A 五、编程题（22分） 1．设计一个函数模板，实现两数的交换，并用int、float、double、char类型的数据进行测试。 #include 填空题 1．MVC模式中，M代表(Model(模型）)，V代表(View（视图）)，C代表(Controller（控制器）)。2．Struts2框架主要有两个核心配置文件:struts.properties和(struts.xml)。 3．struts2的框架校验包含字段校验和(非字段校验)。 单项选择题 1．J2EE中，（ D ）类的（）方法用于创建对话。 A．HttpServletRequest、getSession B．HttpServletResponse、newSession C．HtttpSession、newInstance D．HttpSession、getSession 2．下列哪个不是HTML的常用标记（D） A． B． J2简答题 1、简述J2的四层模型。 运行在客户端机器上的客户层组件;运行在J2服务器上的层组件;运行在J2服务器上的业务逻辑层组件;运行在服务器上的企业信息系统层软件 2、什么是对象持久化？ 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中、数据文件中等等。 3、简述一下，为什么我们使用它？ ( )是一种为了解决面向对象与关系型数据库存在的互不匹配的现象的技术。简单说：是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据中。本质上就是将数据从一种形式转换到另外一种形式。 原因：用它来架起对象和关系型数据库的桥梁，可解决对象层次的映射、对象关系的映射以及对象的持久化问题。 4、简述一下如何使用实现对象持久化的过程（可画图或用伪码描述） 1:创建对象。在这一步中主要为了进行配置文件的装载操作，读取所有的配置文件并进行解析、 2: 创建对象。通过创建好的对象可以创建一个对象的实例，同时是生成对象实例的工厂，他在整个应用中应该是,唯一的。 3:创建对象。对象类似于数据库的连接对象，可以理解为与数据库建立的一个连接，但是他的功能要比中的对象丰富很多。 4:开始一个事务。在中定义一个事务操作的开始，这是使用进行持久化操作必不可少的步骤 5:进行持久化操作。在这个步骤中可以读取或者保存对象。 6:结束事务。在操作完成之后还要进行显式的结束事务的操作。 7:关闭。类似于释放数据库的连接。 5、为什么要实现序列化？ 1、序列化以某种存储形式使自定义对象持久化 2、序列化将对象转换为可传输方式从一个地方传递到另一个地方 3、序列化使程序更具维护性 6、比较一下中的（）和（）方法 1、创建的会和绑定到当前线程,而不会。 2 、创建的线程会在事务回滚或事物提交后自动关闭,而必须手动关闭 7、比较一下中的（）和（）方法，以及如何保证每次都是从数据库读取而不是在缓存中读？ （）和（）方法均可以根据指定的实体类和从数据库读取记录，并返回与之对应的实体对象。 设计模式主要分三个类型:创建型、结构型和行为型。 其中创建型有： 一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点 二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。 三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。 四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。 五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 行为型有： 六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。 八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。 九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。 十、State，状态模式：允许对象在其内部状态改变时改变他的行为。对象看起来似乎改变了他的类。 十一、Strategy，策略模式：定义一系列的算法，把他们一个个封装起来，并使他们可以互相替换，本模式使得算法可以独立于使用它们的客户。 十二、China of Responsibility，职责链模式：使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系 十三、Mediator，中介者模式：用一个中介对象封装一些列的对象交互。 十四、Visitor，访问者模式：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这个元素的新操作。 十五、Interpreter，解释器模式：给定一个语言，定义他的文法的一个表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 十六、Memento，备忘录模式：在不破坏对象的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 结构型有： 十七、Composite，组合模式：将对象组合成树形结构以表示部分整体的关系，Composite使得用户对单个对象和组合对象的使用具有一致性。 十八、Facade，外观模式：为子系统中的一组接口提供一致的界面，fa?ade 提供了一高层接口，这个接口使得子系统更容易使用。 十九、Proxy，代理模式：为其他对象提供一种代理以控制对这个对象的访问 1、简述J2EE的四层模型。 运行在客户端机器上的客户层组件 运行在J2EE服务器上的Web层组件 运行在J2EE服务器上的业务逻辑层组件 运行在EIS服务器上的企业信息系统层软件 2、什么是对象持久化？ 即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中、XML数据文件中等等。 3、简述一下ORMAPPING，为什么我们使用它？ ORM(Object Relational Mapping)是一种为了解决面向对象与关系型数据库存在的互不匹配的现象的技术。简单说：ORM是通过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据中。本质上就是将数据从一种形式转换到另外一种形式。 原因：用它来架起对象和关系型数据库的桥梁，可解决对象层次的映射、对象关系的映射以及对象的持久化问题。 4、简述一下如何使用Hibernate实现对象持久化的过程（可画图或用伪码描述）STEP 1:创建Configuration对象。在这一步中主要为了进行配置文件的装载操作，读取所有的配置文件并进行解析 STEP 2: 创建SessionFactory对象。通过创建好的Configuration对象可以创建一个sessionFactory对象的实例，同时是生成Session对象实例的工厂，他在整个应用中应该是唯一的。 STEP 3:创建Session对象。 Session对象类似于数据库的连接对象，可以理解为与数据库建立的一个连接，但是他的功能要比JDBC中的Connection对象丰富很多。 STEP 4:开始一个事务。在Java中定义一个事务操作的开始，这是使用Hibernate 进行持久化操作必不可少的步骤 STEP 5:进行持久化操作。在这个步骤中可以读取或者保存Java对象。 STEP 6:结束事务。在操作完成之后还要进行显式的结束事务的操作。 STEP 7:关闭Session。类似于释放数据库的连接。 5、为什么要实现序列化？ 1、序列化以某种存储形式使自定义对象持久化 2、序列化将对象转换为可传输方式从一个地方传递到另一个地方 3、序列化使程序更具维护性 6、比较一下sessionFactory中的opensession（）和getcurrentsession（）方法。 1、getCurrentSession创建的session会和绑定到当前线程,而openSession不会。 2 、getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而 总复习题 复习参考资料： 1.GoF 设计模式 2.设计模式解析 3.易学设计模式 4.大话设计模式 5.深入浅出设计模式 以参考资料为主，模拟试题1-5中有些题答案在一些附加资料中 模拟试题1 一、选择题（分值20） 1. 设计模式一般用来解决什么样的问题( ) A.同一问题的不同表相 B不同问题的同一表相 C.不同问题的不同表相 D.以上都不是 2. 下列属于面向对象基本原则的是( ) A.继承 B.封装 C.里氏代换 D都不是 3. Open-Close原则的含义是一个软件实体( ) A.应当对扩展开放，对修改关闭. B.应当对修改开放，对扩展关闭 C.应当对继承开放，对修改关闭 D.以上都不对 4. 当我们想创建一个具体的对象而又不希望指定具体的类时，可以使用（）模式。 A.创建型 B.结构型 C行为型 D.以上都可以 5. 要依赖于抽象，不要依赖于具体。即针对接口编程，不要针对实现编程,是( )的表述 A. 开-闭原则 B. 接口隔离原则 C. 里氏代换原则 D. 依赖倒转原则 6. 依据设计模式思想,程序开发中应优先使用的是( )关系实现复用。 A, 委派 B.继承 C创建 D.以上都不对 7. 设计模式的两大主题是( ) A.系统的维护与开发 B 对象组合与类的继承 C.系统架构与系统开发 D.系统复用与系统扩展 8. 单体模式中,两个基本要点( )和单体类自己提供单例 A .构造函数私有 B.唯一实例 C.静态工厂方法 D.以上都不对 9. 下列模式中,属于行为模式的是( ) A.工厂模式 B观察者 C适配器以上都是 10. “不要和陌生人说话”是( )原则的通俗表述 一、填空 2. 在Tomcat服务器中部署Web应用程序时，可以直接将Web程序归档文件W AR存放到tomcat服务的_______________ webapps ________目录中。 3. 在Servlet中用来接收客户表单数据的两个常用方法为____ doGet _________、_____doPost________。 4. 在一个应用程序中不同的页面共享数据时，最好的JSP内置对象为__________application /session _______。 7. JDBC中_________DriverManager/Connection _接口用于连接数据库。 8. Resulset接口的_________next()_方法可以使结果集指针指向下行数据。 二、单选选择 1．在JSP中如果要导入java.io.* 包，应该使用_________A______指令。 A. page B. taglib C. include D. forward 2．如果当前JSP页面出现异常时需要转到一个异常页，需要设置page 指令的__D______属性。 A. Exception B. isErrorPage C. error D. errorPage 3．在MVC模式中，核心内容为____C____。 A. view B. control C. model D. 不确证 8．sesson对象的_______D___方法用于判断是否为开始新会话。 A. begin() B. isNewSessionID() C. invalidate() D. isNew() ９．创建JSP应用程序时，配置文件web.xml应该在程序下的____C______目录中。 A. admin B. servlet C. WEB-INF D. WebRoot 10．下列不属于URL的组件部分为____________D___________。 A. 协议 B. IP地址或域名 C.目录或文件 D. 服务器名称 11．下列表单 比较几种创建型模式的优缺点，仔细考察这几种模式的区别和相关性。 第一类是工厂模式，工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。 工厂模式有三种形态：简单工厂模式；工厂方法模式；抽象工厂模式是。前两者是类的创建模式，后者是对象的创建模式。 简单工厂： 简单工厂模式是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例，涉及工厂角色(Creator)、抽象产品(Product)角色及具体产品(Concrete Product)角色等三个角色。 优点： 模式的核心是工厂类，该类中含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅负责“消费”产品。 简单工厂模式实现了对责任的分割。 缺点： 当产品类有复杂的多层次等级结构时，工厂类只有它自己。 模式中工厂类集中了所有的产品创建逻辑，形成一个无所不知的全能类。 将多个创建逻辑放在一个类中，当产品类有不同接口种类时，工厂类需要判断在什么时候创建某种产品，使得系统在将来进行功能扩展时较为困难。 该模式采用静态方法作为工厂方法，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。 简单工厂模式只在有限的程度上符合“开-闭”原则。 工厂方法： 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。工厂方法模式是简单工厂模式的进一步抽象和推广，其基本思想是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。 优点： 多态性：客户代码可以做到与特定应用无关，适用于任何实体类 子类可以重写新的实现，也可以继承父类的实现。加一层间接性，增加了灵活性。 良好的封装性，代码结构清晰。扩展性好，在增加产品类的情况下，只需要适当修改具体的工厂类或扩展一个工厂类，就可“拥抱变化”屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。 典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。 缺点：创建型设计模式的习题
课后答案——C++语言程序设计教程(第二版)
Java中常见设计模式面试题
第8章_泛型编程习题_参考答案
J2EE复习题
J2EE考试题目及答案
设计模式主要分三个类型
J2EE简答题及答案
设计模式总复习题
J2ee复习题3
设计模式-创建型模式的优缺点比较