java bean 工厂模式_通过annotation(注解)实现BeanFactory工厂模式(三)

工厂模式是大家熟知的一种设计模式，在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