工厂模式是大家熟知的一种设计模式,在spring BeanFactory将这模式运用自如。 前面讲过如果通过xml配置的方式实现,今天我们来讲讲如何通过注解的方式实现工厂模式。 主要思路
扫描classPath下的的类,将这些class存储到setmap中
遍历set中的class,找出被自定义facory注解注解过的的class,以beanId,class的对象形式封装到一个map集合里
暴露一个方法getBean,通过beanId查找对于的class的对象,匹配成功后返回该对象
同样回顾下常见的简单工厂写法
创建一个接口类Pizza
public interface Pizza{
public float getPrice();
}
MargheritaPizza 类
public class MargheritaPizza implements Pizza{
public float getPrice() {
System.out.println("8.5f");
return 8.5f;
}
}
CalzonePizza 类
public class CalzonePizza implements Pizza{
public float getPrice() {
System.out.println("2.5f");
return 2.5f;
}
}
建立工厂类PizzaFactory
通过传入参数id,选择不同的实例类,如果后续不断的增加新类,会频繁的修改create方法,不符合开闭原则
public class PizzaFactory {
public Pizza create(String id) {
if (id == null) {
throw new IllegalArgumentException("id is null!");
}
if ("Calzone".equals(id)) {
return new CalzonePizza();
}
if ("Margherita".equals(id)) {
return new MargheritaPizza();
}
throw new IllegalArgumentException("Unknown id = " + id);
}
}
使用annotation注解方式
注解方式减少对代码的侵入,避免xml配置的繁琐,是spring高版喜欢使用的方式
创建ClassPathSpringScanner 扫描类
获取当前classLoad下的所有class文件
public class ClassPathSpringScanner {
public static final String CLASS_SUFFIX = ".class";
private ClassLoader classLoader = getClass().getClassLoader();
public Set> getClassFile(String packageName) throws IOException {
Map classMap = new HashMap<>(32);
String path = packageName.replace(".", "/");
/**
* 通过classLoader加载文件,循环遍历文件,转换class文件
*/
Enumeration urls = classLoader.getResources(path);
while (urls!=null && urls.hasMoreElements()) {
URL url = urls.nextElement();
String protocol = url.getProtocol();
/**
* 如果是文件
*/
if ("file".equals(protocol)) {
String file = URLDecoder.decode(url.getFile(), "UTF-8");
File dir = new File(file);
if(dir.isDirectory()){
parseClassFile(dir, classMap);
}else {
throw new IllegalArgumentException("file must be directory");
}
}
}
Set> set = new HashSet<>(classMap.size());
for(String key : classMap.keySet()){
String className = classMap.get(key);
try {
set.add(getClass().forName(className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
return set;
}
/**
* 递归算法把class封装到map集合里
* @param dir
* @param packageName
* @param classMap
*/
protected void parseClassFile(File dir, Map classMap){
if(dir.isDirectory()){
File[] files = dir.listFiles();
for (File file : files) {
parseClassFile(file, classMap);
}
} else if(dir.getName().endsWith(CLASS_SUFFIX)) {
String name = dir.getPath();
name = name.substring(name.indexOf("classes")+8).replace("\\", ".");
addToClassMap(name, classMap);
}
}
private boolean addToClassMap(String name, Map classMap){
if(!classMap.containsKey(name)){
classMap.put(name, name.substring(0, name.length()-6)); //去掉.class
}
return true;
}
只要被Factory注解过的类,都能通过beanId实例化对象。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Factory {
/**
* 用来表示对象的唯一id
*/
String id();
}
创建 BeanFactory 接口
public interface BeanFactory {
public Object getBean(String id);
}
创建BeanFactory 的实现类AnnApplicationContext
将扫描后得到的class封装到一个map里,找出有被Factory注解的类,以beanId,class对象的键值对形式存储。
public class AnnApplicationContext implements BeanFactory{
private Map factoryClasses = new LinkedHashMap();
private Set> classSet = new HashSet();
ClassPathSpringScanner scanner = new ClassPathSpringScanner();
/*
* 构造函数初始化扫描获取所有类
*/
public AnnApplicationContext(String packageName) {
try {
//扫描classPath下的所有类,并返回set
classSet = scanner.getClassFile(packageName);
/**
* 遍历所有类,找出有factory注解的类,并封装到linkedHashMap里
*/
for (Class> cls : classSet){
Factory factory = (Factory) cls.getAnnotation(Factory.class);
if(factory != null)
try {
factoryClasses.put(factory.id(), cls.newInstance());
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 输入的id,对应到factoryGroupedClasses的关系,实例化工厂对象
* @param beanId
* @return
*/
@Override
public Object getBean(String id) {
return factoryClasses.get(id);
}
MargheritaPizza 类
添加注释Factory,定义beanId:Margherita
@Factory(id = "margherita")
public class MargheritaPizza implements Pizza{
public float getPrice() {
System.out.println("8.5f");
return 8.5f;
}
}
CalzonePizza 类
添加注释Factory,定义beanId:Calzone
@Factory(id = "calzone")
public class CalzonePizza implements Pizza{
public float getPrice() {
System.out.println("2.5f");
return 2.5f;
}
}
测试下
public static void main(String[] args) {
/**
* 扫描com.annotation.factory下的类
*/
AnnApplicationContext factoryProcessor = new AnnApplicationContext("com.annotation.factory.spring");
Pizza p= (Pizza) factoryProcessor.getBean("Calzone");
p.getPrice();
}
好了,看完代码应该很清楚了,注解是不是给我们带来很多方便了。 留个思考题,如何默认通过类的名字,首个字母小写来作为beanId