经过annotation(注解)实现BeanFactory工厂模式(三)

工厂模式是你们熟知的一种设计模式，在spring BeanFactory将这模式运用自如。 前面讲过若是经过xml配置的方式实现，今天咱们来说讲如何经过注解的方式实现工厂模式。 主要思路

1. 扫描classPath下的的类，将这些class存储到setmap中
2. 遍历set中的class，找出被自定义facory注解注解过的的class，以beanId，class的对象形式封装到一个map集合里
3. 暴露一个方法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<Class<?>> getClassFile(String packageName) throws IOException {
         
        Map<String, String> classMap = new HashMap<>(32);
        String path = packageName.replace(".", "/");
        /**
         * 经过classLoader加载文件,循环遍历文件，转换class文件
         */
        Enumeration<URL> 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<Class<?>> 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<String, String> 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<String, String> classMap){
        if(!classMap.containsKey(name)){
            classMap.put(name, name.substring(0, name.length()-6)); //去掉.class
        }
        return true;
    }

自定义工厂注解@Factory

只要被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<String, Object> factoryClasses = new LinkedHashMap<String, Object>();
    
    private Set<Class<?>> 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