工厂模式
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
介绍
意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不同条件下创建不同实例时。
如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
关键代码：创建过程在其子类执行。
应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
说白了，就是通过工厂的生产接口，生产所需要的对象（自己的理解）；
BaseDao
介绍
BaseDao接口的过人之处在于：一般是提供从数据库 增加、删除、修改记录、查询所有记录、查询符合某个条件记录、取得某条记录等方法的底层数据操作自定义类。
由于我们可能操作多个数据库表，这样就需要为每个表提供一个操作他的类 xxDAO， 这些DAO继承BaseDAO 就可以省略很多重复代码（从数据库 增加、删除、修改记录、查询所有记录、查询符合某个条件记录、取得某条记录等方法的代码）。
其次对于泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
实现（案例代码）
本实例使用的是Druid连接池，需要导入三个包：common-dbUtils,druid,mysql-connector-java/
项目目录
| 包 | 作用 |
|---|---|
| annotation | 关联对象和表的注解类 |
| base | 存放BaseDao，DaoFactory类，实现工厂的主要功能 |
| base.impl | Base实现类 |
| dao | xxxDao类 |
| dao.impl | xxxDao实现 |
| entity | 实体类 |
| service | 业务代码 |
| test | 测试类 |
| util | 工具类 |
daoConfig.properties
//工厂中使用Class.forName来创建xxxDao的实现类
UserDaoClass=demo.me.dao.impl.UserDaoImpl
druid.properties
//Druid配置文件
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/basedao?useUnicode=true&characterEncoding=utf-8&useSSL=false&&serverTimezone=GMT
username=root
password=root
maxActive=10
validationQuery:SELECT 1
testWhileIdle:true
testOnBorrow:false
testOnReturn:false
完整代码见https://github.com/InnovationLou/BaseDao
核心代码：
package demo.me.base;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import demo.me.dao.UserDao;
/**
* 工厂类：向service层输送Dao的实现类
* 单例模式,双重锁
* @author admin
*
*/
public class DaoFactory {
private static DaoFactory factory=null;
private static UserDao userDao=null;
private DaoFactory() {
Properties prop=new Properties();
@SuppressWarnings("static-access")
InputStream is=DaoFactory.class.getClassLoader().getSystemResourceAsStream("daoConfig.properties");
try {
prop.load(is);
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
String UserDaoClass=prop.getProperty("UserDaoClass");
try {
userDao=(UserDao) Class.forName(UserDaoClass).newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static DaoFactory getInstance() {
if(factory==null) {
synchronized(DaoFactory.class) {
factory=new DaoFactory();
}
}
return factory;
}
public UserDao getUserDao() {
return userDao;
}
}
package demo.me.base;
import java.sql.SQLException;
import java.util.List;
public interface BaseDao<T> {
public List<T> findAll() throws SQLException;
public T findById(int id) throws SQLException;
public int add(T entity) throws Exception;
public int delete(int id) throws SQLException;
public int update(T entity) throws Exception;
}
//------------------------------------------------------
package demo.me.base.impl;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import demo.me.annotation.Bean;
import demo.me.annotation.Id;
import demo.me.base.BaseDao;
import demo.me.util.DruidUtil;
public class BaseDaoImpl<T> implements BaseDao<T> {
private Connection conn;
private QueryRunner qr;
// 操作的xxxDao字节码对象
private Class<T> clazz;
// 操作的表明
private String tableName;
@SuppressWarnings("unchecked")
public BaseDaoImpl() {
conn = DruidUtil.getConn();
qr = new QueryRunner();
Type type = this.getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) type;
clazz = (Class<T>) pt.getActualTypeArguments()[0];
// tableName=clazz.getSimpleName();
Bean[] classType = clazz.getAnnotationsByType(Bean.class);
tableName = classType[0].value();
System.out.println(tableName);
}
@Override
public List<T> findAll() throws SQLException {
String sql = "select * from " + tableName;
List<T> list = qr.query(conn, sql, new BeanListHandler<>(clazz));
return list;
}
@Override
public T findById(int id) throws SQLException {
String idFieldName = null;
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
if (field.isAnnotationPresent(Id.class)) {
idFieldName = field.getName();
}
}
String sql = "select * from " + tableName + " where " + idFieldName + "=?";
System.out.println(sql);
T entity = qr.query(conn, sql, new BeanHandler<>(clazz), new Object[] { id });
return entity;
}
@Override
public int add(T entity) throws Exception {
Class<? extends Object> claz = entity.getClass();
String sql = "insert into " + tableName + " ( ";
Field[] fields = claz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (i != fields.length - 1) {
sql += field.getName() + ",";
} else {
sql += field.getName() + ")";
}
}
sql += " values(";
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (i != fields.length - 1) {
sql += " ?,";
} else {
sql += "?)";
}
}
System.out.println(sql);
Object[] objs = new Object[fields.length];
Object fieldValue = null;
for (int i = 0; i < objs.length; i++) {
Field field = fields[i];
PropertyDescriptor pd = new PropertyDescriptor(field.getName(), claz);
fieldValue = pd.getReadMethod().invoke(entity, null);// 请求字段的get方法
objs[i] = fieldValue;
}
int result = qr.update(conn, sql, objs);
return result;
}
@Override
public int delete(int id) throws SQLException {
String idFieldName = null;
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
if (field.isAnnotationPresent(Id.class)) {
idFieldName = field.getName();
}
}
String sql = "delete from " + tableName + " where " + idFieldName + "=?";
System.out.println(sql);
int result = qr.update(conn, sql, new Object[] { id });
return result;
}
@Override
public int update(T entity) throws Exception {
Class<? extends Object> claz = entity.getClass();
String sql = "update " + tableName + " set ";
Field[] fields = claz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (!field.isAnnotationPresent(Id.class)) {
sql += field.getName() + " =?,";
}
}
sql = sql.substring(0, sql.length() - 1);// 去掉最后一个逗号
sql += " where ";
String idFieldName = null;
for (Field field : fields) {
if (field.isAnnotationPresent(Id.class)) {
idFieldName = field.getName();
}
}
sql += idFieldName + "=?";
System.out.println(sql);
Object[] objs = new Object[fields.length];
Object fieldValue = null;
int j = 0;// 加到数组中的位置
for (int i = 0; i < objs.length; i++) {
Field field = fields[i];
PropertyDescriptor pd = new PropertyDescriptor(field.getName(), claz);
fieldValue = pd.getReadMethod().invoke(entity, null);// 请求字段的get方法
if (!field.isAnnotationPresent(Id.class)) {
objs[j] = fieldValue;
j++;
} else {
objs[objs.length - 1] = fieldValue;
}
}
int result = qr.update(conn, sql, objs);
return result;
}
}
扫一扫
1073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
