Java的工厂模式解耦与Spring的 IOC容器应用

最新推荐文章于 2024-08-23 13:33:02 发布

码涤生

最新推荐文章于 2024-08-23 13:33:02 发布

阅读量334

点赞数 1

分类专栏： java高阶文章标签： java工厂模式 Spring IOC原理 Spring对象作用范围依赖注入的三种方式

本文链接：https://blog.csdn.net/lmlzww/article/details/105363279

版权

java高阶专栏收录该内容

14 篇文章 1 订阅

订阅专栏

学习java以及Spring也有一段时间了，但是对Spring的IOC这一块一直有点照本宣科的意思，这次重新看了Spring的相关教程，通过写个博客希望可以把相关的知识串联起来，在以后写代码的时候可以做到心中有数！

日常我们代码中存在的问题——代码耦合

在软件工程中我们常提出的一句话就是“高内聚，低耦合”简而言之就是在项目开发的过程中我们应该尽可能的减少代码块之间的关系，这样避免一部分代码出问题的时候连带大面积的代码瘫痪，不能一行代码出问题连带骨米诺效应。减少代码之间的耦合，从大的方面来说也可以使得多人协同，每个人完成自己的部分后通过接口连接，从而组成整个项目，甚至说是现在的前后端分离开发，你或许也可以把这个看成是一种接触前后端的耦合，这是个人的一些理解，也未必见得正确。代码的耦合我们只能避免一部分并不能做到完全的解耦合，在下面的例子中我们展示的是简单的代码之间的耦合：

public class JdbcDemo1 {
    public static void main(String[] args) throws  Exception{
        //1.注册驱动
//        DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");

        //2.获取连接
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/eesy","root","1234");
        //3.获取操作数据库的预处理对象
        PreparedStatement pstm = conn.prepareStatement("select * from account");
        //4.执行SQL，得到结果集
        ResultSet rs = pstm.executeQuery();
        //5.遍历结果集
        while(rs.next()){
            System.out.println(rs.getString("name"));
        }
        //6.释放资源
        rs.close();
        pstm.close();
        conn.close();
    }
}

例如我们在第一个注册驱动的环节如何使用的是DriverManager.registerDriver(new com.mysql.jdbc.Driver());那么我们在编译的时期就要满足有com.mysql.jdbc.Driver这个驱动的要求，可是如果我们这个驱动还没有安装或是这是一个由其他团队成员正在开发中的一个工具类呢？我们就不能正常的编写我们这一部分，回报编译器的错误！这也就是我们所说的依赖，这个依赖时在编译器就已经产生了的，我们要做的就是解除在编译期的依赖使得在运行时期再依赖。

在这里是通过new关键字来建立了一个mysql的jdbc驱动，new测存在使得编译期就要求这个驱动类是存在的，这时候我们可以使用反射来创建对象从而避免使用new关键字（Class.forName("com.mysql.jdbc.Driver");）。但是这时候我们可以想——如果我们要更换驱动的类型，我们还需要来代码中修改吗？不，这时我们就可以通过配置文件来告诉程序我们想要的驱动是什么的。这也是我们接下来通过工厂模式来解除耦合的实现思路！

Java的工厂模式

上边我们提到要避免new关键字，我们这里的工厂模式就是通过配置文件我们要什么样的对象，然后程序通过工厂的工具类来读取配置文件，创建相应的对象，提供给程序。

配置文件：

accountService=com.itheima.service.impl.AccountServiceImpl
accountDao=com.itheima.dao.impl.AccountDaoImpl

工厂类——多例类型：

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            } catch (Exception e) {
            System.out.println("配置文件初始化失败");
        }
    }

    public static Object getBean(String beanName){
        Object bean = null;
        try {
            String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);
            bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
        }catch (Exception e){
            e.printStackTrace();
        }
        return bean;
    }
}

在工厂类的后面我们写了一个多例类型，这里多例类型的意思就是说，在程序中一个类如果创建多个对象，那么这些对象都不是同一个——他们的ID不同，这个的原因是newInstance这个方法每执行一次都会调用默认构造函数创建对象，所以每次产生的都也是新的对象，这时候我们不用担心程序的线程安全因为我们每次的调用每个对象都也会只使用自己对象的成员，但重复的创建对象，对程序的性能无疑是大的影响，这时候我们需要考虑每个类只创建一个对象供程序全局的使用，因为每个类只会创建一个对象，所以我们管这种模式称为单例模式。在单例模式中我们有类的实例域，也就是说在类中定义变量，并且在方法中操作，这时候就会引发线程安全的问题，就像类中有一个account的成员变量，并且初始值为1，每个用户的调用这个对象想得到这个成员account初始值加一的返回值，这时候每个调用都会把account加一，因为account是大家的；所以也就是有第一个调用会得到一个正确的值，这也就引发了所谓的线程安全！但是如果我们把这个成员变量放到了方法内，这个线程安全问题也就解决了，因为方法的每次调用都是初始化。下面是Java工厂模式单例对象的代码实现：

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }
/**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

初始化的时候静态代码块会初始化一次，这时候会根据配置文件创建相应的对象，对象被存在容器中。之后如果程序的那个地方需要使用对象，则直接根据bean的对象名称来容器中获取。在这里的工厂类使我们自己编写，在Spring中你可以通过相应的配置项来指定你的类是多例的还是单例的，单例和多例的容器也不同，这一点Spring的框架可以自动的检测识别。或者说是你使用了不同的容器来创建，spring就会自动的来决定你的对象是单例还是多例。

测试类：

public class Client {

    public static void main(String[] args) {
        //IAccountService as = new AccountServiceImpl();
        for(int i=0;i<5;i++) {
            IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
            System.out.println(as);
            as.saveAccount();
        }

    }
}

Spring的IOC容器

在Spring中有两个核心的概念即IOC、AOP（面向切面编程），IOC容器是Spring的核心，可以说Spring是一种基于IOC容器的编程框架，与Spring相关的另一个框架SpringBoot就是基于注解开发的Spring IOC，这使得程序中可以摆脱配置文件，而通过注解的方式实现。那么IOC容器到底是什么呢？我们可以分开理解：IOC（Inversion of Control）控制反转、容器——在IOC容器中提供了提供了我们在配置文件中配置的对象，程序中使用到的对象我们可以通过这个获取，而不需要在程序中通过new创建，正是因为不需要通过new创建了，所以对对象的创建权利实现了翻转，以前通过new创建对象对于程序来说是主动的，但是现在对象是通过Spring框架的IOC容器提供得来的，相对来说是被动的。Spring的框架也是通过这个技术来对对象实现管理，很大程度上解除了程序间的依赖，降低耦合。在上边工厂的单例模式中我们可以明显发现，对象创建完后并不是直接就被应用了的，而是先存到容器中，使用的时候再来查找取出（对象的创建方式实际上课可以分为两类的：立即加载和懒加载，这一部分后边来介绍）。所以我们可以简单的理解为分为，对象的创建以及对象的查找。IOC控制反转也正是分为了两部分依赖注入、依赖查找。

引入了Spring的框架也就相当于在工厂模式中的用于生产对象的工厂类可以抛弃了，这一部分的内容交由Spring来完成，在使用的过程中只要给工厂对象指出配置文件是哪个就可以了：

public class Client {
   public static void main(String[] args) {
        Resource resource = new ClassPathResource("bean.xml");
        BeanFactory factory = new XmlBeanFactory(resource);
        IAccountService as  = (IAccountService)factory.getBean("accountService");
        System.out.println(as);
    }
}

在这里的配置文件采用的是XML格式的：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>

在上面我们容器创建使用的是BeanFactory，这个容器在创建对象的时候采用的是延时加载的策略，我们有时候也叫做懒加载，也就是说什么时候根据id获取对象了什么时候才真正的创建对象。这样的加载方式适用于我们上边说得到的多例对象。然而适用于单例对象的是ApplicationContext，他在创建对象的时候采用的策略是立即加载，即只要一读取配置文件就立马创建配置文件中的对象。如果我们在配置文件中没有明显的指定对象是单例还是多例那么，那么Spring框架会根据我们的容器BeanFactory或ApplicationContext来自动的判给我们对象是单例还是多例，如果指定了的话就会按照我们指定的。

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="singleton"></bean>

public class Client {
    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as  = (IAccountService)ac.getBean("accountService");
//      IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);
        as.saveAccount();
    }
}

在这里我们可以看到从容器中取出对象的时候我们需要进行一个转换，这个转换可以是在getBean的隐参前加（）进行强制的转换也可以是在getBean（）的方法中添加一个类型参数来实现转换。至于说为什么转换，是因为在容器内部所有的对象都是被超类所持有的（Object obj =对象）所以取出来之后并不能直接的使用而是要通过指明对象是哪个类型的，才可以调用这个对象独有的方法。

我们可以通过类关系图发现，ApplicationContext实际上是BeanFactory的子类：

ApplicationContext的三个常用实现类：
ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)    FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）   AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。

Bean对象的声明周期

在上边我们将Bean分为单例对象和多例对象，这两种的区别也是在于单例对象一个容器中一个类型的实例只会创建一个，而多例对象则是每次通过Bean ID 引用都会创建一个新的对象，也就是说在一个容器中与一个类型的实例会不止一个。然而从Bean对象的声明周期的角度来说多例对象是当我们使用的时候由Spring框架来给我们创建，且一直存在，直到由于长时间不用且不被引用的时候才被Java的垃圾回收器回收。单例对象是当我们加载配置文件的时候就由框架给我们创建，并且只要容器在就会一直存在，当容器消失则对象的声明周期也就终结，他的声明周期与容器同步。

Bean对象创建的方式可以分为三种，即通过默认的构造函数构造，通过普通方法构造、通过静态方法构造。如果我们写了一个带参数的构造方法，这时候还是可以使用构造函数创建，只不过是我们需要注入相应的参数，这一部分我们会在下面注入的三种方式见到：

 <!-- 第一种方式：使用默认构造函数创建。
            在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
            采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    -->

    <!-- 第二种方式： 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
    <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
    -->

    <!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
    <bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
    -->

我们一直在将单例对象，多例对象，这个的分类实际上是属于Bean对象作用范围分类的范畴，除过单例（singleton 默认值）、多例（prototype）、还有作用于web的请求范围（request）、作用于web的会话范围（session）以及作用于集群环境的（global-session）。

依赖注入的三种方式

我们知道IOC控制反转包括依赖注入与依赖查找，依赖注入就是为了减少程序间的耦合。上边的我们见到的通过配置文件告诉框架或工厂来创建的对象，我们都没有给对象传递用于实例化得参数，然而参数是可以传的，能传递的数据类型可以分为：基本类型与String、其他的Bean类型、符合类型/集合类型。进行诸如的方式可以有三种：通过构造函数、通过set方法、通过注解，这也可以理解成是给类中的域负值的几种方式：通过创建参数时的构造函数传递参数来进行赋值，通过我们类中的访问器setXxxx( )

通过构造函数传递：

public class AccountServiceImpl implements IAccountService {

    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}

 <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
 </bean>

    <!-- 配置一个日期对象,这里体现的就是可以传递其他的Bean类型 -->
    <bean id="now" class="java.util.Date"></bean>

通过set方法传递：

public class AccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public void  saveAccount(){
        System.out.println(Arrays.toString(myStrs));
    }
}

<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <array>
                <value>222222</value>
            </array>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

用于给List结构集合注入的标签有，list、array、set；用于个Map结构集合注入的标签，map、props，总的来说，结构相同，标签可以互换，这里说的结构就是bean的内部结构。

通过注解：

待续..................................................................

码涤生

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

Java的工厂模式解耦与Spring的 IOC容器应用

日常我们代码中存在的问题——代码耦合