框架漫谈之spring(一)工厂模式实现程序解耦，spring框架的引出

1.程序的耦合度

我们来看如下的代码

// 表现层
public class UserController {
public static void main(String[] args) {
IUserService userService = new UserServiceImpl();
userService.saveUser();
}
}

// 业务实现类接口
public interface IUserService {
void saveUser();
}
// 业务实现类
public class UserServiceImpl implements IUserService {
private UserDao userDao = new UserDao();
public void saveUser() {
userDao.saveUser();
}

// 持久层接口
public interface IUserDao{
void saveUser();
}
// 持久层实现类
public class UserDaoImpl implements IUserDao {
System.out.println("保存一个用户");
}

该程序模拟了某网站注册用户的流程，我们来看上述的程序，表面上来看是没有一点问题的，但仔细的看。表现层与业务层、业务层与持久层紧紧的互相依赖关联，这与我们开发程序的高内聚低耦合原则相违背。我们也来看一看原始的JDBC程序

//注册mysql驱动
DriverManager.deregisterDriver(new com.mysql.jdbc.Driver());

点进jdbc注册驱动的源码可以知道，当加载这个类时候 已经注册，这样相当于注册了两次。从程序的角度的来看即使注册了2次所浪费的效率基本上可以忽略不计。原始的JDBC注册驱动 紧紧的依赖着mysql的jar包，一旦没有mysql的jar包编译时就会报错，所以我们真正写JDBC注册驱动的是用这行代码

//注册mysql驱动  改进了注册2次的问题 并且做到了编译时候不依赖
Class.forName("com.mysql.jdbc.Driver");

从JDBC和上述模拟用户注册的案例来看，当有一个类在编译时候,紧紧依赖于另外一个类的存在.

当没有依赖类存在时,程序不能编译.此时我们就称这两个类有很想的依赖关系,高耦合度

开发中应该遵循的依赖原则:编译时不依赖,运行时在依赖。

2.工厂模式实现程序解耦

使用工厂模式：

工厂为我们创建类的对象，从而解决层和层之间的依赖关系。

这种依赖关系我们也叫，程序的耦合。

package test.factory;
import test.dao.IUserDao;

/**
* 工厂模式： 用于削减计算机程序耦合
*
* @author ZhuPengWei
* @Date 2017年9月24日
*/
public class BeanFactory {
private static BeanFactory factory;
static {
factory = new BeanFactory();
}

// 单例模式：私有化构造函数
private BeanFactory() {
}

// 提供一个公共方法，获取该类的实例
public static BeanFactory newInstance() {
return factory;
}

/**
* 用于生成一个的持久层实现类对象
*
* @return
*/
public IUserDao getUserDao() {
try {
return (IUserDao) Class.forName("test.dao.impl.UserDao").newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}

用户业务层实现类也作出如下的改进

public class UserServiceImpl implements IUserService {
// private IUserDao userDao = new UserDao();
IUserDao userDao = BeanFactory.newInstance().getUserDao();

public void saveUser() {
userDao.saveUser();
}
}

3.工厂模式改进

仔细的来看，上面的工厂模式存在了大量的问题，首先它在反射创建对象时候使用了硬编码，存在硬编码的问题。其次此工厂模式不利于程序的扩充，首先开发需要写获取持久层的方法以及业务层的方法，一旦有新的解耦需求工厂类就得添加新的方法，这样是十分不利于维护的。下面，将对于这两点进行改进

在类路径下创建bean.properties

USERDAO = test.dao.impl.UserDaoImpl
USERSERVICE =test.service.impl.UserServiceImpl

package test.factory;

import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.ResourceBundle;

/**
* 工厂模式： 用于削减计算机程序耦合
*
* @author ZhuPengWei
* @Date 2017年9月24日
*/
public class BeanFactory {
// 此类可以通过静态方法获取对象，参数是资源文件的名称（不写程序的扩展名）。
// 底层是类加载器，因此只能读取类路径下的资源文件(src目录下)。
private static ResourceBundle bundle = ResourceBundle.getBundle("bean");

// 定义一个容器，用于存储配置文件中配置的对象
private static Map<String, Object> beans = new HashMap<String, Object>();

private static BeanFactory factory;
static {
factory = new BeanFactory();
// 初始化容器
Enumeration<String> keys = bundle.getKeys();
while (keys.hasMoreElements()) {
// 取出每一个key
String key =  keys.nextElement();
// 根据key，获取全限定类名
String classPath = bundle.getString(key);
try {
// 根据classPath反射创建类对象
Object object = Class.forName( classPath).newInstance();
// 存入map中
beans.put(key, object);
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
throw new ExceptionInInitializerError("初始化容器失败！");
}

}
}

// 单例模式：私有化构造函数
private BeanFactory() {
}

// 提供一个公共方法，获取该类的实例
public static BeanFactory newInstance() {
return factory;
}

/**
* 根据参数获取Bean对象
* @param beanName 参数
* @return Bean对象
*/
public Object getBean(String beanName){
return beans.get(beanName);
}

/**
* 用于生成一个的持久层实现类对象
* 由于返回值是一个固定的接口，所以导致了创建其他类对象时，必须写新的方法
* @return
*/
// public IUserDao getUserDao() {
// try {
// return (IUserDao) Class.forName("test.dao.impl.UserDao").newInstance();
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
// }
}

package test.service.impl;

import test.dao.IUserDao;
import test.factory.BeanFactory;
import test.service.IUserService;
/**
* 用户业务层实现类
*
* @author ZhuPengWei
* @Date  2017年9月24日
*/
public class UserServiceImpl implements IUserService {
// private IUserDao userDao = new UserDao();
//IUserDao userDao = BeanFactory.newInstance().getUserDao();

//改造后的方法：获取bean对象，根据bean名称。得到的对象是Object，需要强转
private IUserDao userDao  = (IUserDao) BeanFactory.newInstance().getBean("USERDAO");

public void saveUser() {
userDao.saveUser();
}
}

4.spring框架引出

那我们为什么要用spring呢？首先它的好处之一就是方便解耦简化开发。

spring是一个大工厂，可以将所有对象创建和依赖维护交给spring去管理

暂时本文也只是说明了这一个好处。

什么是spring框架？

spring是一个开源框架。它是为了解决企业应用开发的复杂性而创建的，框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供继承的框架。spring使用基本的JAVABean来完成以前只可能由EJB完成的事情。spring的用途也不仅仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从spring中收益。spring的核心就是控制反转（ioc）和面向切面（aop）。简单的来说，spring是一个分层的一站式轻量级开源框架

spring是用来干什么的？

这个介绍的不错