对初识Spring工厂模式的思考

  • 时间:
  • 来源:互联网
  • 文章标签:

Spring的基本理论知识

  • 什么是Spring?

Spring 是分层的 Java SE/EE应用 full-stack 轻量级开源框架,以 IoC(Inverse Of Control:
反转控制)和 AOP(Aspect Oriented Programming:面向切面编程)为内核,提供了表现层 Spring
MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多
著名的第三方框架和类库,逐渐成为使用最多的Java EE 企业应用开源框架。

  • spring 的体系结构
  • Spring的优势?

方便解耦,简化开发
AOP 编程的支持
声明式事务的支持(配置的方式)
方便程序的测试(好像集成了Junit)
方便集成各种优秀框架
降低 JavaEE API
Java 源码是经典学习范例

栗子

我们有这么一个场景,需要实现一个账户保存的功能。这个很简单,无非就是两个接口、两个实现类、再加一个测试类的事情。

创建账户持久层接口 IAccountDao,定义保存账户抽象方法

public interface IAccountDao {
    /**
     * 保存账户
     */
    void saveAccount();
}

实现账户持久层接口 AccountDaoImpl,并创建并实现 saveAccount 方法,输出保存信息。

public class AccountDaoImpl implements IAccountDao {
 @Override
    public void saveAccount() {
        System.out.println("已保存账户~!");
    }
}

定义账户业务层接口 IAccountService,并定义一个保存账户的方法

public interface IAccountService {
    /**
     * 保存账户
     */
    void saveAccount();
}

实现账户业务层接口 AccountServiceImpl,实现调用持久层 saveAccount 方法实现保存账号抽象方法。

public class AccountServiceImpl implements IAccountService {
  /**
     * 持久层对象
     */
    private IAccountDao accountDao = new AccountDaoImpl();

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

最后编写表现层 Test,测试下该用例是否能正常运行

public class Test{
    public static void main(String[] args) {
        IAccountService as = new AccountServiceImpl();
        as.saveAccount();
    }
}

// 以下为输出结果
已保存账户~!

分析:

1、首先要清楚一个概念:耦合

  • 程序的耦合

耦合:程序间的依赖关系。包括 类之间的依赖、方法间的依赖。
解耦:降低程序间的依赖关系
实际开发中应该做到编译期不依赖,运行时才依赖。
解耦的思路:
第一步:使用反射来创建对象,而避免使用new关键字。
第二步:通过读取配置文件来获取要创建的对象全限定类名
在实际开发中,耦合是必然存在的,故只能尽量降低依赖,不能消除。

在上面的这几段代码中,耦合程度是很高的。为啥说高耦合呢,假若我们不小心删了 AccountDaoImpl ,整个程序都无法通过编译。那么这时候就需要改写代码,使用工厂模式解耦!!!

2、配置文件的使用

  • 为什么要使用配置文件呢??
    使用配置文件可以达到一个目的,就是我们可以将一些固定不变的内容抽取出来单独保存,通过调用的方式获取其实例。

代码的改写

1、创建 bean.properties 文件,保存账户业务层实现类的路径 AccountServiceImpl 和账户持久层接口实现类 AccountDaoImpl 信息

accountService=service.AccountServiceImpl
accountDao=dao.AccountDaoImpl

2、创建Bean对象的工厂模式 BeanFactory

public class BeanFactory {

    /**
     * Properties 对象
     */
    private static Properties props;

    /**
     * 静态代码块为 Properties 对象赋值
     */
    static {
        try {
            // 实例化对象
            props = new Properties();
            // 使用类加载器获取配置文件位置,获取 properties 文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
        } catch (IOException e) {
            throw new ExceptionInInitializerError("初始化 properties 文件异常!");
        }
    }

    /**
     * 获取对象实例
     * @param beanName 对象实例名
     * @return {@link Object} 对象实例
     */
    public static Object getBean(String beanName) {
        Object bean = null;
        try {
            String beanPath = props.getProperty(beanName);
            bean = Class.forName(beanPath).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}

此时,账户业务层实现类就可以这么写:

public class AccountServiceImpl implements IAccountService {
    // 通过工厂模式获取 AccountDaoImpl 的实例
    private IAccountDao accountDao = (IAccountDao) BeanFactory.getBean("accountDao");
    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

表现层这么写:

public class Test {
    public static void main(String[] args) {
        IAccountService as = (AccountServiceImpl) BeanFactory.getBean("accountService");
        as.saveAccount();
    }
}

在这里插入图片描述
这时候相比之前耦合程度就大大降低了,这时候尽管删除持久层包下的实现类 AccountDaoImpl,编译是不会出错,但是没有该类是肯定运行不了。编译器会报 java.lang.ClassNotFoundException 异常,而不是 Error。
耦合只是相对而言,工厂模式也不是完美的,仍然存在很多可以优化的地方,但是可以减少部分耦合就是对程序性能的一个大幅度的提升。

本文链接http://www.taodudu.cc/news/show-82866.html