设计模式-工厂模式-简单工厂模式+反射+配置文件+泛型

最新推荐文章于 2023-08-03 22:37:27 发布
最新推荐文章于 2023-08-03 22:37:27 发布
阅读量489 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37817767/article/details/108678478
版权

目录

一、概念

1.1 什么是工厂模式

参考资料：

1.2 什么是反射

参考资料：JAVA中的反射机制

二、优势

1、支持多态
2、代码复用，使得同一段代码适应更多不同场景；
3、工厂使得调用方与被调用方实现解耦，减少依赖；
4、抽象工厂在具体类修改扩张的时候，调用方不用修改代码；

三、劣势

四、简单工厂+反射+配置文件+泛型的实现

4.1 实现思路

以工具作为对象分析：

1、定义工具：

  • 创建工具接口Tools，定义工具功能；
  • 创建飞机、车、船抽象类，实现工具接口Tools，定义这3类工具的功能；
  • 创建大飞机、小飞机、大车、小车、大船、小车具体类分别继承飞机、车、船抽象类，说明具体的功能；

2、定义配置文件：

  • 配置文件modelTest.properties存放每个具体类的全类名；

3、定义工厂：

  • 工厂加载配置文件
  • 工厂提供生产具体类的方法，该方法具备根据参数名生产具体类的能力；
    • 根据参数从加载的配置文件中获取具体类的全类名；
    • 根据全类名利用反射创建具体的工具类；
    • 方法返回值为泛型，支持各种具体类的实例化；

4、定义用户：

  • 用户通过调用工厂中的生产方法，将需要创建的类的标志以参数的形式传递过去，进行工具类实例创建；
  • 需要创建的类的标志：配置文件中全类名的key

4.2 UML类图

«interface» Tools +void effect Aircraft Ship Vehicle VehicleSmall VehicleBig ShipBig ShipSmall AircraftBig AircraftSmall ModelFactoryDemo ToolsFactory -Properties properties T getInstance modelTest aircraft_big aircraft_sml ship_big ship_sml vehicle_big vehicle_sml 调用getInstance(String nameKey) 调用modelTest配置文件 具体类被指向而生产对应实例

4.3 定义抽象工具（接口）

工具 ==> 飞机、车子、船

package cn.com.study.demo.modelFactory.po;

/**
 * 工具接口
 * @author Mr.qing
 *
 */
public interface Tools {

	/**
	* 工具的作用
	*/
	public abstract void effect();

}

/**
* 飞机
* @author Mr.qing
*
*/
public abstract class Aircraft implements Tools {

	/**
	 * 飞机的作用
	 */
	@Override
	public abstract void effect();

}                                                                 
                                                                                                                       
/**                                                                                                                    
 * 车                                                                                                                   
 * @author Mr.qing                                                                                                     
 *                                                                                                                     
 */                                                                                                                    
public abstract class Vehicle implements Tools {                                                                       
                                                                                                                       
	/**                                                                                                                  
	 * 车的作用                                                                                                              
	 */                                                                                                                  
	@Override                                                                                                            
	public abstract void effect();                                                                                       
}    
                                                                                                                  
/**
 * 船
 * @author Mr.qing
 *
 */
public abstract class Ship implements Tools {

	/**
	 * 船的作用
	 */
	@Override
	public abstract void effect();
}

4.4 定义具体的工具类型

大飞机、小飞机；大车、小车；大船、小船；

package cn.com.study.demo.modelFactory.po.Impl;  
                                                                                                                       

import cn.com.study.demo.modelFactory.po.Aircraft;     
public class AircraftBig extends Aircraft {                                                                            
                                                                                                                       
	@Override                                                                                                            
	public void effect() {                                                                                               
		System.out.println("大飞机拉航空货！");                                                                                  
	};                                                                                                                   
}                                                                                                                      
public class AircraftSmall extends Aircraft {

	@Override
	public void effect() {
		System.out.println("小飞机坐人！");
	};
}


import cn.com.study.demo.modelFactory.po.Vehicle;
public class VehicleBig extends Vehicle {

	@Override
	public void effect() {
		System.out.println("大车公司用！");
	};
}
public class VehicleSmall extends Vehicle {

	@Override
	public void effect() {
		System.out.println("小车家庭用！");
	};
}


import cn.com.study.demo.modelFactory.po.Ship;
public class ShipBig extends Ship {

	@Override
	public void effect() {
		System.out.println("大船拉沙！");
	};
}
public class ShipSmall extends Ship {

	@Override
	public void effect() {
		System.out.println("小船拉游客！");
	};
}

4.5 定义生成工具的厂子

ToolsFactory.java

package cn.com.study.demo.modelFactory.factory;                                                                                                                                                         
import java.io.IOException;                                                                                            
import java.util.Properties;                                                                                           
                                                                                                                       
import org.slf4j.Logger;                                                                                               
import org.slf4j.LoggerFactory;                                                                                        
import org.springframework.core.io.ClassPathResource;                                                                  
import org.springframework.core.io.support.EncodedResource;                                                            
import org.springframework.core.io.support.PropertiesLoaderUtils;                                                                                      
                                                                                                                       
/**                                                                                                                    
 * 工具工厂口                                                                                                              
 * @author Mr.qing                                                                                                     
 *                                                                                                                     
 */                                                                                                                    
public abstract class ToolsFactory {                                                                                   
	                                                                                                                     
	private static final Logger logger = LoggerFactory.getLogger(ToolsFactory.class);                                    
	                                                                                                                     
	static Properties properties = null;                                                                                 
	                                                                                                                     
	public static <T>T getInstance(String nameKey){                                                                      
		                                                                                                                 
		//加载配置文件                                                                                                         
		init();                                                                                                          
		                                                                                                                 
		T instance = null;                                                                                               
		//从配置文件获取全类名                                                                                                                 
		String className = properties.getProperty(nameKey);                                                              
		                                                                                                                 
		try {                                                                                                            
			Class clazz = Class.forName(className);                                                                      
			//生产具体工具                                                                                                             
			instance = (T)clazz.newInstance();                                                                           
			                                                                                                             
		} catch (ClassNotFoundException e) {                                                                             
			e.printStackTrace();                                                                                         
		} catch (InstantiationException e) {                                                                             
			e.printStackTrace();                                                                                         
		} catch (IllegalAccessException e) {                                                                             
			e.printStackTrace();                                                                                         
		}                                                                                                                
		                                                                                                                 
		return instance;                                                                                                 
		                                                                                                                 
	}                                                                                                                    
	                                                                                                                     
	/**                                                                                                                  
	 * 加载配置文件                                                                                                            
	 * @param isForceLoad 是否强制加载配置文件 是-true                                                                              
	 */                                                                                                                  
	private static void init() {                                                                                         
		                                                                                                                 
		if(properties != null) {                                                                                         
			return;                                                                                                      
		}                                                                                                                
		                                                                                                                 
		                                                                                                                 
		//配置文件加载                                                                                                         
		try {                                                                                                            
			                                                                                                             
			properties = new Properties(System.getProperties());                                                         
            PropertiesLoaderUtils.fillProperties(properties,                                                           
                    new EncodedResource(new ClassPathResource(                                                         
                            "META-INF/res/modelTest.properties"), "UTF-8"));                                           
                                                                                                                       
		} catch (IOException e) {                                                                                        
			logger.error("加载配置文件失败失败", e);                                                                            
            throw new RuntimeException(e);                                                                             
		}                                                                                                                
	}                                                                                                                    
	                                                                                                                     
	/**                                                                                                                  
	 * 加载配置文件                                                                                                            
	 */                                                                                                                  
	static {                                                                                                             
		init();                                                                                                          
	}                                                                                                                    
}

4.6 配置文件

modelTest.properties

aircraft_big=cn.com.study.demo.modelFactory.po.Impl.AircraftBig
aircraft_sml=cn.com.study.demo.modelFactory.po.Impl.AircraftSmall

ship_big=cn.com.study.demo.modelFactory.po.Impl.ShipBigl
ship_sml=cn.com.study.demo.modelFactory.po.Impl.ShipSmall

vehicle_big=cn.com.study.demo.modelFactory.po.Impl.VehicleBig
vehicle_sml=cn.com.study.demo.modelFactory.po.Impl.VehicleSmall

4.7 用户使用工具

ModelFactoryDemo .java

package cn.com.study.demo.modelFactory;

import cn.com.study.demo.modelFactory.factory.ToolsFactory;
import cn.com.study.demo.modelFactory.po.Impl.AircraftBig;

/**
 * 工厂设计模式demo
 * @author Mr.qing
 *
 */
public class ModelFactoryDemo {
	
	public static void main(String[] args) {
		
		Tools t = ToolsFactory.getInstance("aircraft_big");
		
		t.effect();
		
	}

}

 
执行结果：
	大飞机拉航空货！

4.8 总结

工厂 + 反射 + 配置文件 + 泛型的模式下：

  • 配置文件是工具、工厂、用户之间的纽带：
    • 配置文件存放工具具体类的全类名以及类标识；
    • 用户调用工厂生产工具时，需要生产那种工具，就将该工具类在配置文件中的类标识传递给工厂就可以生产对应工具了；
    • 工厂根据用户传递过来的类标识，从配置文件中获取具体类全类名，利用反射完成对应工具的生产；
  • 在这种情况下：
    • 工厂与工厂生产的产品在编译时是没有关联的，只有在运行时根据实际需要工厂生产具体的产品，解耦很明显；
  • 泛型作用：
    • 泛型扩大了工厂的生产能力，原理工厂只能生产工具类产品，使用泛型后，工厂就是一个全能工厂了，可以生产包括工具在类的所有产品；
    • 只要有对应的产品类，并且在配置文件中完成产品类配置，工厂就可以生产这种产品；

五、应用场景

  • 系统中有多于一个的产品族，而每次只使用其中某一产品族。
  • 在很多软件系统中需要更换界面主题或者一键换肤。
  • DAO层支持多种类型的数据库，动态切换时。
  • 不同操作系统代码差异化，可以切换不同操作系统时。

六、应用案例分析

参考资料：

七、参考资料汇总

简单工厂模式、工厂方法模式和抽象工厂模式有何区别？
设计模式之抽象工厂模式
JAVA中的反射机制
Java设计模式及应用场景之《抽象工厂模式》
反射在工厂模式上的应用
IOC的实现原理—反射与工厂模式
SpringIOC底层原理代码实现

zdaiqing
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
泛型，IO流，工厂模式
cai13844831460的博客
12-14 451
泛型的好处： 在编译时对类型严格检查，操作类中的数据时不需要强制类型转换 泛型类数据类型参数只支持引用数据类型，不支持基本数据类型 定义泛型方法输出不同类型数组中的元素： public static <E> void print(E[] num){ for(E n:num){ System.out.print(n+" "); } } 泛型方法的类型通配符： 方法的参数只能是Father或子类的类型 ...
JAVA设计模式之工厂模式
自律的西瓜L
04-13 353
本文将对工厂模式进行详细的分析与讲解，主要脉络是由浅入深，从简单工厂到抽象工厂模式，逐渐地递进分析并体现优化过程，阐述简单工厂、工厂方法、抽象工厂之间的关系，认清每种模式的定位以及如何理解。本文章是笔者查阅网上资料并结合自己的理解总结而来，若有不同见解的网友欢迎参与讨论共同进步。
Java设计模式（三）创建型- 抽象工厂模式（史上最全抽象工厂模式）与使用场景以及优缺点
移动端开发与最新技术
05-18 266
抽象工厂模式
Java泛型 反射工厂模式_反射和工厂模式
weixin_29001419的博客
02-27 311
Java反射反射就是把Java类中的各个成分映射成一个个的Java对象，即在运行状态中，对于任意一个类，都能够知道这个类的所以属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性。动态获取信息及动态调用对象方法的功能叫Java的反射机制。主要由以下的类来实现反射机制(这些类都位于java.lang.reflect包中)：Class类：代表一个类。 Field类：代表类的成员变量(成员变量也...
23种设计模式-抽象工厂模式（Android应用场景介绍）
qq_19764133的博客
04-17 384
抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。
JAVA设计模式--程序设计--反射--注解--泛型
04-06
Java设计模式、程序设计、反射、注解和泛型是Java开发中的核心概念，它们各自在不同的场景下发挥着重要作用，构建出高效、可维护的软件系统。 首先，Java设计模式是面向对象编程中的一种最佳实践，是解决常见问题的...
rttr：C ++反射库
02-03
5. **事件**: 虽然C++标准库没有事件系统，rttr提供了一个接口，允许你注册和触发事件，这对于创建可观察的或响应式的设计模式十分方便。 6. **类型注册与命名**: 开发者可以为自定义类型注册元数据，这些元数据...
C#一键生成实体类-带源码.zip
02-28
3. **简单工厂模式**：简单工厂是一种设计模式，用于提供一个创建对象的公共接口，而无需指定具体的类。在生成实体类的场景中，简单工厂可能用于根据数据库连接信息和表结构创建对应的实体类实例。 4. **三层架构**...
java高级+struts2总结
10-11
2. **设计模式**：设计模式是解决软件设计中常见问题的经验总结，包括单例模式、工厂模式、观察者模式、装饰模式等。在实际开发中，它们能提高代码的可重用性和可维护性。 3. **多线程**：Java提供了一套完整的多...
java学习笔记及设计模式
10-19
Java学习笔记及设计模式是程序员进阶过程中必不可少的资源，涵盖了广泛的Java基础知识和高级概念，同时结合了设计模式这一软件工程的重要组成部分。本资源集合旨在帮助开发者深化对Java语言的理解，提升编程技能，并...
设计模式——工厂模式在开发中的应用（简单计算器）
08-11
这个是http://blog.csdn.net/dawanganban/article/details/9884681博客中java设计模式的源代码。下载前请先看《设计模式——工厂模式在开发中的应用》一文。
Java设计模式综合应用场景
06-23
Java设计模式综合应用场景，实验报告内含核心代码，三种以上设计模式综合使用场景，图形界面 本资源已经失效，新链接如下：https://download.csdn.net/download/dtlscsl/11247009
设计模式-创建型模式（单例、简工、工方）
Onecat_j的博客
12-01 217
1.单例模式 确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建模式。 1.1 饿汉式单例类 当类被加载时，静态变量instance被初始化，此时类的私有构造函数会被调用，单例类的唯一实例将被创建。但是不管用不用得到，这个实例都被创建，占用内存空间。 对应的Java片段： class EagerSingleton{ private static final EagerSingleton instance = new EagerS
工厂模式—简单工厂模式（传统，加反射）
qq_43581401的博客
08-02 271
简单工厂模式： 核心：一个接口，一个继承接口的集具体类，一个工厂类 本质：工厂类的生产产品实例根据创建实例时传入参数的不同，动态的选择应该创建哪一个具体类的实例。 interface IFruit{ public void eat(); } //产品类 class Apple implements IFruit{ @Override public void eat() {...
Java设计模式——工厂模式
最新发布
qq_58461006的博客
08-03 217
Override1）定义PC类，实现Computer@Override@Override@Override2）定义Service类，实现Computer@Override@Override@Override注意工厂类可以单例的（添加判断该对象是或否已经创建过）getComputer可以是静态的getComputer是工厂类的方法，基于相同的参数类型返回不同的对象。
返回泛型类的工厂模式
xxc2020_NJU
02-11 161
工厂模式返回泛型类。通过一个工厂创建不同接口的多个实现类。
【软件设计】工厂模式之反射技术+读取配置文件
weixin_51293984的博客
09-15 1694
properties键值对 properties . setProperty(String key , String value);//获取properties值 properties . getProperty(String key);//从输入流中读取属性列表（键值对） properties . load(InputStream inStream);
工厂设计模式+反射+XML配置文件实战演练
weixin_41444522的博客
09-28 821
通过Java的多态性，我们能知道，当父类引用可以指向子类对象从而调用父类中子类的重写方法，以及接口引用可以指向实现类对象从而调用实现类对象的重写方法。但在项目中，我发现代码直接使用dao层接口引用就能使用实现类的方法，为了了解其中的过程，我查阅了相关资料，了解到这个是Spring的IoC容器的作用。 Spring的IoC即Inversion of Control，意思就是控制反转控制反转指的就是...
Java设计模式之《抽象工厂模式》详解 实现抽象工厂及应用场景
奋斗的IT青年
12-19 3194
抽象工厂模式（Abstract Factory）        抽象出来一个基础接口定义了产品功能(对应抽象产品角色)，每个实现此接口的子类就是具体产品(对应具体产品角色)，然后定义一个工厂接口（对应抽象工厂角色），实现了工厂接口的子类就是具体工厂（对应具体工厂角色），这时候，接口编程的优点就体现了，我们可以随时新增具体产品类（只需要实现产品接口），只需要同时新增一个工厂类，客户端就可以轻松调用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值