此文章对工厂模式一步一步进行了抽取，对对象的创建过程分布进行抽取，因为学习java的时间不长，有些地方可能不对，希望读者能给出评定，留言给我,在正式写入工厂方法之前有些准备东西，也就是前面的代码，可以不用看直接看工厂模式：
注：在书写的时候，有代码的大小写错误问题，由于时间关系有的未能改过来，希望读者见谅，哪有不对的地方请留言！
工厂模式：
第一步：创建数据库：
（1）在开始菜单启动项的运行中输入cmd,弹出控制台的窗口
（2）在窗口中输入语句mysql -u root -p 然后回车，在正确连接的情况下，会显示enter password,这时我们输入密码，在我的机器上市root,输入正确后，我们就可以创建数据库了，例如create database factory; 即创建了名字为factory的数据库（可以使用show databases;语句查看本机上的所有数据库）
（3）创建表，首先确定使用的数据库（使用语句use factory;）,创建数据库表：
-------以购物模块的用户和对应的收货地址为例
1）------创建用户表
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
`id` int(11) NOT NULL auto_increment,
`userName` varchar(100) default NULL,
`password` varchar(100) default NULL,
`nickName` varchar(100) default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
2）创建地址表
DROP TABLE IF EXISTS `t_address`;
CREATE TABLE `t_address` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(255) default NULL,
`phone` varchar(100) default NULL,
`postcode` varchar(100) default NULL,
`user_id` int(11) default NULL,
PRIMARY KEY (`id`),
KEY `user_address` (`user_id`),
CONSTRAINT `user_address` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
（4）创建数据库关系表多对应的实体类：
1）User实体类：
package cn.hsm.model;
import java.util.List;
public class User {
private int id;
private String userName;
private String password;
private String nickName;
private List<Address> addresses;//不需要进行分页的
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public List<Address> getAddresses() {
return addresses;
}
public void setAddresses(List<Address> addresses) {
this.addresses = addresses;
}
}
2）Address实体类
package cn.hsm.model;
public class Address {
private int id;
private String name;
private String phone;
private String postcode;
private User user;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getPostcode() {
return postcode;
}
public void setPostcode(String postcode) {
this.postcode = postcode;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
(5)使用带的辅助类：
-------分页类
package cn.hsm.util;
public class Pager<T> {
long totalRowsAmount; // 总行数,hibernate语句返回的是Long型的数据
int pageSize = 4; // 每页行数、即显示的数据个数
int currentPage = 1; // 当前页码
int totalPages; // 总页数
int pageStartRow;// 显示页的开始显示数据行、返回的结果集中的
int pageEndRow;// 显示页的末尾显示数据行、返回的结果集中的,基本用不到
/*
* @return
*/
public long getTotalRowsAmount() {
return totalRowsAmount;
}
/*
* @param t 设置总行数
*/
public void setTotalRowsAmount(long n) {
this.totalRowsAmount = n;
}
public int getPageSize() {
return pageSize;
}
/*
* @param pageSize 设置每页显示的数据个数、即行数
*/
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getCurrentPage() {
return currentPage;
}
/*
* @param currentPage 设置当前页码数
*/
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
/*
* 总页数的获取
*/
public int getTotalPages() {
return (int) ((this.getTotalRowsAmount() - 1) / this.getPageSize() + 1);
}
public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}
public int getPageStartRow() {
if (getCurrentPage() * getPageSize() < getTotalRowsAmount()) {
pageStartRow = getPageEndRow() - getPageSize() + 1;
} else {
pageStartRow = (int) (getPageSize() * (getTotalPages() - 1) + 1);
}
return pageStartRow;
}
/*
* @param pageStartRow 设置当前页显示的开始数据行数
*/
public void setPageStartRow(int pageStartRow) {
this.pageStartRow = pageStartRow;
}
public int getPageEndRow() {
if (getCurrentPage() * getPageSize() < getTotalRowsAmount()) {
pageEndRow = getCurrentPage() * getPageSize();
} else {
pageEndRow = (int) getTotalRowsAmount();
}
return pageEndRow;
}
/*
* @param pageStartRow 设置当前页显示的末尾数据行数
*/
public void setPageEndRow(int pageEndRow) {
this.pageEndRow = pageEndRow;
}
}
---------资源文件辅助类
package cn.hsm.util;
import java.io.IOException;
import java.util.Properties;
public class PropertiesUtil {
private static Properties jdbcProp;//prop是Property的缩写
public static Properties getJdbcProp() {
try {
if(jdbcProp==null) {
jdbcProp = new Properties();
jdbcProp.load(PropertiesUtil.class.getClassLoader().getResourceAsStream("jdbc.properties"));
}
} catch (IOException e) {
e.printStackTrace();
}
return jdbcProp;
}
}
--------数据库处理辅助类
package cn.hsm.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
public class DBUtil {
public static Connection getConnection() {
Properties prop = PropertiesUtil.getJdbcProp();
String username = prop.getProperty("userName");
String password = prop.getProperty("password");
String url = prop.getProperty("url");
Connection conn = null;
try {
conn = DriverManager.getConnection(url, username, password);
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
// 数据源的使用
/*Connection con = null;
try {
Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
DataSource ds = (DataSource) envCtx.lookup("jdbc/msg");
con = ds.getConnection();
} catch (NamingException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return con;*/
}
public static void close(Connection con) {
try {
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close(PreparedStatement ps) {
try {
if (ps != null)
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
public static void close(ResultSet rs) {
try {
if (rs != null)
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
（6）资源文件：jdbc.properties
userName=root
password=root
url=jdbc:mysql://localhost:3306/factory
driver=com.mysql.jdbc.Driver
（7）自定义异常类：ShopException
package cn.hsm.exception;
public class ShopException extends RuntimeException {
private static final long serialVersionUID = 1465191015391787906L;
public ShopException() {
super();
}
public ShopException(String message, Throwable cause) {
super(message, cause);
}
public ShopException(String message) {
super(message);
}
public ShopException(Throwable cause) {
super(cause);
}
}
（8）创建dao层基本类
package cn.hsm.service.base;
import itat.zttc.shop.model.Pager;
import itat.zttc.shop.model.SystemContext;
import itat.zttc.shop.util.MyBatisUtil;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.session.SqlSession;
public class BaseDao<T> {
public void add(T obj) {
SqlSession session = null;
try {
session = MyBatisUtil.createSession();
session.insert(obj.getClass().getName()+".add",obj);
session.commit();
} catch (Exception e) {
e.printStackTrace();
session.rollback();
} finally {
MyBatisUtil.closeSession(session);
}
}
public void update(T obj) {
SqlSession session = null;
try {
session = MyBatisUtil.createSession();
session.update(obj.getClass().getName()+".update", obj);
session.commit();
} catch (Exception e) {
e.printStackTrace();
session.rollback();
} finally {
MyBatisUtil.closeSession(session);
}
}
public void delete(Class<T> clz,int id) {
SqlSession session = null;
try {
session = MyBatisUtil.createSession();
session.delete(clz.getName()+".delete", id);
session.commit();
} catch (Exception e) {
e.printStackTrace();
session.rollback();
} finally {
MyBatisUtil.closeSession(session);
}
}
@SuppressWarnings("unchecked")
public T load(Class<T> clz,int id) {
SqlSession session = null;
T t = null;
try {
session = MyBatisUtil.createSession();
t = (T)session.selectOne(clz.getName()+".load",id);
} finally {
MyBatisUtil.closeSession(session);
}
return t;
}
@SuppressWarnings("unchecked")
public T loadBySqlId(String sqlId,Map<String,Object> params) {
SqlSession session = null;
T t = null;
try {
session = MyBatisUtil.createSession();
t = (T)session.selectOne(sqlId,params);
} finally {
MyBatisUtil.closeSession(session);
}
return t;
}
@SuppressWarnings("unchecked")
public T loadBySqlId(String sqlId,Object obj) {
SqlSession session = null;
T t = null;
try {
session = MyBatisUtil.createSession();
t = (T)session.selectOne(sqlId,obj);
} finally {
MyBatisUtil.closeSession(session);
}
return t;
}
//传值的时候直接传入例如User.class,传值时知道使用那个具体类的
public List<T> list(Class<T> clz,Map<String,Object> params) {
return this.list(clz.getName()+".list", params);
}
public List<T> list(String sqlId,Map<String,Object> params) {
List<T> list = null;
SqlSession session = null;
try{
session = MyBatisUtil.createSession();
list = session.selectList(sqlId,params);
} finally {
MyBatisUtil.closeSession(session);
}
return list;
}
public Pager<T> find(Class<T> clz,Map<String,Object> params) {
return this.find(clz.getName()+".find", params);
}
public Pager<T> find(String sqlId,Map<String,Object> params) {
return null;
}
}
（9）创建实体类对应的数据库操作的dao层()
1）User实体类对应的dao层
package cn.hsm.dao;
import cn.hsm.model.User;
import cn.hsm.util.Pager;
public interface UserDao {
public void add(User user);
public void delete(int id);
public void update(User user);
public User loadByUsername(String username);
public User load(int id);
public Pager<User> find(String name);//真分页数据
public User login(String username,String password);
}
------User实体类对应dao的实现类
package cn.hsm.dao.impl;
import cn.hsm.util.Pager;;
import cn.hsm.exception.ShopException;
import cn.hsm.model.User;
import java.util.HashMap;
import java.util.Map;
public class UserMybatisDaoImpl extends BaseDao<User> implements UserDao {
@Override
public void add(User user) {
User tu = this.loadByUsername(user.getUsername());
if(tu!=null)
{throw new ShopException("要添加的用户已经存在");}
super.add(user);
}
@Override
public void delete(int id) {
//TODO 需要先删除关联对象
super.delete(User.class, id);
}
@Override
public void update(User user) {
super.update(user);
}
@Override
public User loadByUsername(String username) {
return super.loadBySqlId(User.class.getName()+".load_by_username", username);
}
@Override
public User load(int id) {
return super.load(User.class, id);
}
@Override
public Pager<User> find(String name) {
Map<String,Object> params = new HashMap<String, Object>();
if(name!=null&&!name.equals(""))
params.put("name", "%"+name+"%");
return super.find(User.class, params);
}
@Override
public User login(String username, String password) {
User u = this.loadByUsername(username);
if(u==null) throw new ShopException("用户名不存在!");
if(!password.equals(u.getPassword()))
{ throw new ShopException("用户名密码不正确");}
return u;
}
}
2)Address实体类对应的dao
package cn.hsm.dao;
import cn.hsm.model.Address;
import java.util.List;
public interface AddressDao {
public void add(Address address,int userId);
public void update(Address address);
public void delete(int id);
public Address load(int id);
public List<Address> list(int userId);
}
----------Address实体类的dao的实现类
package cn.hsm.dao.impl;
import cn.hsm.model.Address;
import cn.hsm.exception.ShopException;
import cn.hsm.model.User;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class AddressMybatisDaoImpl extends BaseDao<Address> implements AddressDao {
private IUserDao userDao;
public AddressDao() {
userDao = DAOFactory.getUserDao();
}
@Override
public void add(Address address, int userId) {
User u = userDao.load(userId);
if(u==null)
{throw new ShopException("添加地址的用户不存在");}
address.setUser(u);
super.add(address);
}
@Override
public void update(Address address) {
super.update(address);
}
@Override
public void delete(int id) {
super.delete(Address.class, id);
}
@Override
public List<Address> list(int userId) {
Map<String,Object> params = new HashMap<String, Object>();
params.put("userId", userId);
return super.list(Address.class, params);
}
@Override
public Address load(int id) {
return super.load(Address.class, id);
}
}
（10）工厂模式介绍：
工厂模式是由一个工厂对象决定创建出哪一种产品类的实例，从而让对象的调用者和对象的创建过程分离，当对象的调用者需要对象时，直接向工厂请求，从而避免了对象的
调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性、可拓展性。工厂模式也有一个小小的缺陷：当产品修改时，工厂类也要做相应的修改。
1）静态工厂方法（简单工厂方法）：多个静态方法
工厂设计模式的初步设计：增加dao的工厂类DaoFactory
package cn.hsm.dao;
public class DAOFactory {
public static AddressDao getAddressDao() {
return new AddressJDBCDaoImpl();
}
public static UserDao getUserDao() {
return new UserJDBCDaoImpl();
}
}
--------使用某个对象的时候直接调用工厂中的方法，例如DaoFactory.getUserDao，这里就会调用UserJDBCDaoImpl类的实例对象了
？问题：简单工厂违背了java的OCP（Open Close Principle)原则，即对增加开放，对修改关闭。所以我们使用多态，针对接口编程来符合OCP原则，这样就不会对原来的程序进行任何的修改了，而我们增加实现类的时候也不会对原来的程序进行修改。像上面的程序我们每次修改dao都要在工厂当中进行修改违背了 修改Close。
-------综上，工厂会有dao的工厂，xml文件的工厂，数据库的工厂，再有多个工厂的时候我们首先确定一个接口DaoFactory
2）多个工厂方法，通过不同的方法创建不同类的对象
工厂模式的进一步优化设计：
-------创建模块的dao工厂
package cn.hsm.dao;
public interface DaoFactory {
public UserDao createUserDao();
public AddressDao createAddressDao();
}
-------Mysql的dao实现dao 的工厂，因为使用同一个工厂不需要请求不同的多个工厂对象，所以使用了单例模式
-----单例模式：有些时候，允许自由创建某个类的实例没有意义，还可能造成系统性能下降。如果一个类始终只能创建一个实例，则这个类被称为单例类，这种模式就被称为单例模式。
单例模式主要有如下两个优势：
减少创建Java实例所带来的系统开销
便于系统跟踪单个Java实例的生命周期、实例状态等。
package cn.hsm.dao;
public class MysqlDaoFactory implements DaoFactory {
private static DaoFactory factory = new MysqlDaoFactory();
private MysqlDaoFactory() {}
public static DaoFactory getInstance() {
return factory;
}
@Override
public AddressDao createAddressDao() {
return new AddressMysqlDao();
}
@Override
public UserDao createUserDao() {
return new UserMysqlDao();
}
}
---这样获取UserDao的实例就可以写成：
private UserDao userDao=new MysqlDaoFactory().createUserDao();
------jdbc的实现dao的工厂,单例享元工厂
package cn.hsm.dao;
public class JDBCDaoFactory implements DaoFactory {
private static DaoFactory factory = new JDBCDaoFactory();
/*
* 私有的构造方法防止此类以外的其他类创建该类的实例
*/
private JDBCDaoFactory(){}
public static DaoFactory getInstance() {
return factory;
}
@Override
public UserDao createUserDao() {
return new UserJDBCDao();
}
@Override
public AddressDao createAddressDao() {
return new AddressJDBCDao();
}
}
---这样获取UserDao的实例就可以写成：
private UserDao userDao=new JDBCDaoFactory().createUserDao();
------我们这里假设刚开始使用的是mysql的dao处理，但是某天想用Oracle的dao做处理了，那么我们要想上卖弄那样在建立一个Oracle的dao实现DaoFactory接口，然后使用
----要先添加UserOracleDao实现UserDao中的方法等等。其他的照做。这样又出现了一个问题，在由mysql修改到Oracle的到的时候，我们又要通过new来修改，又违背了OCP原则。
3)使用配置文件，通过字符串判断使用那个工厂
工厂模式进一步优化：（使用配置文件来解决问题）
----使用配置文件的好处;增强代码的灵活性
添加一个dao.properties资源配置文件：
dao.properties中存放的是键值对：
factory=cn.hsm.dao.MysqlDaoFactory
这样代表使用的是mysql的dao实现
以后如果我们要改用使用Oracle的dao实现的时候，我们只需要将key对应的value值改为cn.hsm.dao.OracleDaoFactory
--------创建dao的辅助类DaoUtil
-----首先在PropertiesUtil类中添加如下语句用来读取dao.properties配置文件：
private static Properties daoProp;
public static Properties getDaoProp() {
try {
if(daoProp==null) {
daoProp = new Properties();
daoProp.load(PropertiesUtil.class.getClassLoader().getResourceAsStream("dao.properties"));
}
} catch (IOException e) {
e.printStackTrace();
}
return daoProp;
}
----DaoUtil类
package cn.hsm.util;
import cn.hsm.dao.DaoFactory;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
public class DaoUtil {
//测试
/*public static void main(String[] args) {
System.out.println(createDaoFactory());
}*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static DaoFactory createDaoFactory() {
DaoFactory f = null;
try {
Properties prop = PropertiesUtil.getDaoProp();
String fs = prop.getProperty("factory");
Class clz = Class.forName(fs);//使用反射只需要读取字符串就可以创建对象
String mn = "getInstance";//通过单例创建对象的名称创建对象
Method m = clz.getMethod(mn);//每个工厂获取对象的方法都约定为getInstance
f = (DaoFactory)m.invoke(clz);//获取dao的工厂对象
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return f;
}
}
------此时在创建UserDao的实例对象我们写成如下的代码：
private UserDao userDao=DaoUtil.createDaoFactory().createUserDao();
----这样的话如果我们想修改为jdbc的dao，那么只需要在配置文件里面进行修改，即把factory对应的值改为cn.hsm.dao.JDBCDaoFactory
想改为Oracle的dao，那么只需要在配置文件里面把factory的值改为cn.hsm.dao.OracleDaoFactory即可，反射面向的是字符串来创建对象，我们通过读取配置文件的值就可以使用不同
-----这时候会发现每个创建的实体类的dao 在工厂接口里面定义的，在工厂类方法中实现的对象的创建还是用使用的new 关键字来创建的，做到这里的时候我们会感觉很别扭
4）工厂方法，一个工厂方法，通过字符串判断，创建不同类的对象
工厂模式的再次优化：使用这个版本基本符合了OCP的原则了。
---------DaoFactory类中的代码改为一个方法：
package cn.hsm.dao;
public interface DaoFactory {
public Object getDao(String name);//addressDao、userDao等为参数的值
}
---------将dao.properties配置文件改为：
dao.properties配置文件中的内容：
factory=cn.hsm.dao.PropertiesFactory
userDao=cn.hsm.dao.UserMysqlDao
address=cn.hsm.AddressMysqlDao
---------具体的工厂类改为一个：
package cn.hsm.dao;
import cn.hsm.util.PropertiesUtil;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
public class PropertiesFactory implements DaoFactory {
private static PropertiesFactory f = new PropertiesFactory();
private static Map<String,Object> daos = new HashMap<String, Object>();
private PropertiesFactory() {}
public static IFactoryDao getInstance() {//单例
return f;
}
@Override
public Object getDao(String name) {//传递的参数名为userDao、addressDao等等
try {
if(daos.containsKey(name)){//判断是否已经有过这个dao
return daos.get(name);
}
Properties prop = PropertiesUtil.getDaoProp();
String cn = prop.getProperty(name);
Object obj = Class.forName(cn).newInstance();
daos.put(name, obj);//dao不存在的时候，添加到map集合中去
return obj;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
---------这时候获取实体类dao的语句改为;
private UserDao userDao =（UserDao） DaoUtil.createDaoFactory().getDao("userDao");//从配置文件中读取出字符串后创建对象
---------如果想使用Oracle的UserDao的话，那么只需要将dao.properties配置文件中的userDao改掉就可以了，即：
userDao=cn.hsm.dao.UserOracleDao
对于单例的时候，如果涉及到类中属性的设置的时候，我们不适用单例，例如实体类，如果使用单例，那么实体的对象都用一个id了
但是在实体类的dao中，不涉及属性的设置只涉及方法的调用，那么对于实体类的dao类，我们可以使用单例：
设计方面的一个方法：
方法1：我们可以把已经有的dao给存起来，下一次再用的时候就在存储的空间中来拿，这样就不用在new了，使用Map来存储，就像上面的程序中就使用了这样的一种形式。
方法2：既然是单例，那么就在dao类中正常的写单例模式就可以了，然后将上面的代码改成反射使用Method的，但是这种使用起来太麻烦了，尤其是当类特别多的时候。
--------注：在Spring中有使用依赖注入的方法，用起来更加的简洁，我们只需要声明类的字段，然后有setter和getter方法就可以直接使用了，Spring会帮我们创建相应的类的实例。
1390
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
