业务层和持久层的耦合

模拟一个业务层：

package com.ethan.service;/*
账户业务层的接口*/
public interface AccountService {/*模拟保存账户*/void saveAccount();
}

package com.ethan.service.impl;import com.ethan.service.AccountService;
import com.ethan.dao.AccountDao;
import com.ethan.dao.impl.AccountDaoImpl;
/*
账户的业务层实现类*/
public class AccountServiceImpl implements AccountService {private AccountDao accountDAO = new AccountDaoImpl();public void saveAccount() {accountDAO.saveAccount();}
}

模拟持久层：

package com.ethan.dao;/*
账户的持久层接口*/
public interface AccountDao {/*模拟保存账户*/void saveAccount();
}

package com.ethan.dao.impl;import com.ethan.dao.AccountDao;public class AccountDaoImpl implements AccountDao {public void saveAccount() {System.out.println("保存了账户");}
}

项目结构如下：

业务层和持久层产生了耦合，如果持久层AccountDao的实现类不存在，业务层将抛出编译期异常：

package com.ethan.service.impl;import com.ethan.service.AccountService;
import com.ethan.dao.AccountDao;
import com.ethan.dao.impl.AccountDaoImpl;
/*
账户的业务层实现类*/
public class AccountServiceImpl implements AccountService {private AccountDao accountDAO = new AccountDaoImpl();   //产生耦合，如果实现类不存在，将产生编译期错误public void saveAccount() {accountDAO.saveAccount();}
}

表现层和业务层的依赖

创建一个表现层：

package com.ethan.ui;import com.ethan.service.AccountService;
import com.ethan.service.impl.AccountServiceImpl;/*
模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {AccountService as = new AccountServiceImpl();as.saveAccount();}
}

package com.ethan.ui;import com.ethan.service.AccountService;
import com.ethan.service.impl.AccountServiceImpl;/*
模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {AccountService as = new AccountServiceImpl();   //表现层调用业务层同样产生耦合as.saveAccount();}
}

如果表现层、业务层、持久层三者中的一个的实现类缺失，代码将不能通过编译。解决如下：
创建Bean（可重用组件）对象的工厂
JavaBean：用java语言编写的可重用组件（JavaBean > 实体类）
这个工厂就是创建我们的service和dao对象的。
1.需要一个配置文件来配置我们的service和dao
配置的内容：唯一标识 = 全限定类名 (key = value)
2.通过读取配置文件中配置的内容，反射创建对象

在resources下创建file如下：

该配置文件的内容如下：

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

在包下创建factory.BeanFactory

package com.ethan.factory;import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;public class BeanFactory {//定义一个Properties对象private static Properties props;//使用静态代码块为Properties对象赋值static {//实例化对象props = new Properties();//获取Properties文件的流对象InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");	//注意不要直接用路径创建InputStream，否则文件路径改变将产生异常try {props.load(is);} catch (IOException e) {throw new ExceptionInInitializerError("初始化properties失败");}}/*** 根据Bean的名称获取Bean对象* @param beanName* @return*/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;}
}

这时业务层和表现层作相应变动：

package com.ethan.service.impl;import com.ethan.factory.BeanFactory;
import com.ethan.service.AccountService;
import com.ethan.dao.AccountDao;
/*
账户的业务层实现类*/
public class AccountServiceImpl implements AccountService {AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");public void saveAccount() {accountDao.saveAccount();}
}

package com.ethan.ui;import com.ethan.factory.BeanFactory;
import com.ethan.service.AccountService;/*
模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {AccountService as = (AccountService) BeanFactory.getBean("accountService");as.saveAccount();}
}

这时即使业务层的实现类缺失、或者持久层的实现类缺失，程序在编译时也不会产生错误。

单例模式

每次表现层的代码执行，BeanFactory中将创建新的对象，即这时工厂类是多例的。而如果从始至终只使用一个对象，那么我们称这个类是单例的，这时类成员只被创建一次，从而类成员只会被初始化一次。

单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”
Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

我们可以用静态代码块根据配置文件创建对象，并将这些对象保存在容器中。每当表现层请求对象，我们就从容器中取出对象，这时表现层使用的均是同一个对象。
BeanFactory：

package com.ethan.factory;import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;/*** @author Ethan* @date 2020/1/18 - 12:16*/public class BeanFactory {private static Properties props;//定义一个Map，用于存放我们要创建的对象，我们把它称之为容器private static Map<String, Object> beans;//使用静态代码块为Properties对象赋值static {try {props = new Properties();//获取Properties文件的流对象InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");props.load(is);//实例化容器beans = new HashMap<String, Object>();//取出配置文件中所有的keyEnumeration keys = props.keys();while(keys.hasMoreElements()){String key = keys.nextElement().toString();//根据key获取valueString beanPath = props.getProperty(key);//反射创建对象Object value = Class.forName(beanPath).newInstance();//把key和value存入容器中beans.put(key, value);}} catch (Exception e) {throw new ExceptionInInitializerError("初始化properties失败");}}//根据bean的名称获取对象public static Object getBean(String beanName){return beans.get(beanName);}}

表现层：

package com.ethan.ui;import com.ethan.factory.BeanFactory;
import com.ethan.service.AccountService;/*
模拟一个表现层，用于调用业务层*/
public class Client {public static void main(String[] args) {for (int i = 0; i < 5; i++) {AccountService as = (AccountService) BeanFactory.getBean("accountService"); //每次都得到同一个对象System.out.println(as);as.saveAccount();}}
}