Spring是什么？为什么要使用Spring？

目录

前言

一、Spring是什么？

1.1 轻量级

1.2 JavaEE的解决方案

二、为什么要使用Spring

2.1 传统方式完成业务逻辑

2.2 使用Spring模式完成业务逻辑

三、为什么使用Spring？

前言

本文主要介绍Spring是什么，并且解释为何要去使用Spring，通过一个实际的案例来展示了Spring的强大之处。通过本章正式开始Spring的学习！

一、Spring是什么？

Spring是一个轻量级的Java企业开发的解决方案，整合了许多优秀的设计模式。

1.1 轻量级

对于运行环境是没有要求的

开源的可以，收费的也可以

代码的移植性高

不要实现额外的接口

1.2 JavaEE的解决方案

为什么说Spring是JavaEE中的解决方案呢，在项目开发的过程中类似于Mybatis这种框架只是针对于DAO这一层进行操作，但是Spring对每一个层次都有相对的解决方案，所以这里称Spring为JavaEE中的解决方案。

二、为什么要使用Spring

2.1 传统方式完成业务逻辑

上面只是简单的介绍了一下Spring，对于Spring详细介绍后面再来分析，接下来就分析一下为什么要使用Spring。

对于传统的创建对象的模式，我们是通过直接new对象的方式。假设我现在有一个User类，我要通过UserDao类进行业务操作，然后通过UserService对UserDao类进行控制操作。那么传统的方法就是一步一步的new对象。

1）首先，创建一个User类

public class User {private String id;private String name;
}

2）在UserDao中写出相应的业务操作

public class UserDao {public void login(String name, String password) {// 这里本来是需要写crud的具体操作的，但是为了演示方便就不写了System.out.println("name:"+name+",password:"+password);}
}

3）在UserService中进行相应的操作

public class UserService {UserDao userDao = new UserDao();public void login(String name, String password) {userDao.login(name, password);}
}

4）进行测试，模拟登录的过程

@org.junit.Test
public void test() {UserService userService = new UserService();User user = new User("张三","123456");userService.login(user);
}

此时该业务逻辑就完成了

假设这个时候UserService过时了，我想重新写一个UserServiceNew来操作业务逻辑，对于传统的方式可能就需要对代码进行修改。但是在项目中对代码进行了修改，就意味着要重新测试并部署。

@org.junit.Test
public void test() {//UserService userService = new UserService(); UserServiceNew userServiceNew = new UserServiceNew();User user = new User("张三","123456");//userService.login(user);userServiceNew.login(user);
}

2.2 使用Spring模式完成业务逻辑

此时就涉及解耦合，那么什么是耦合呢？

耦合：指定是代码之间的强联系关系，一方的改变就会影响到另一方

不利于代码的维护
将类硬编码在程序中

接下来就使用Spring模式再对上述业务逻辑进行操作。在测试的过程中，就不new Service对象了而是使用工厂模式去生产Service对象，这样可以解耦

创建一个工厂类

public class BeanFactory {public static UserService getUserService() {return new UserService();}
}

此时利用工厂类再去创建UserService对象

@org.junit.Test
public void test() {//UserService userService = new UserService();UserService userService = BeanFactory.getUserService();User user = new User("张三","123456");userService.login(user);
}

这时候细心的同学可能就发现了，工厂类中也是new对象啊，那不还是有耦合。确实是这样的，接下来就对工厂类继续修改（由于测试流程是一致的，这里就不在展示测试过程）

public class BeanFactory {public static UserService getUserService() {// 这里使用反射创建对象UserService userService = null;try {Class clazz = Class.forName("com.gl.demo.UserService");userService = (UserService) clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return userService;}
}

此时使用反射创建类对象大大降低了耦合，但是再细心一点的同学就会发现，那要是这个类名称变化了呢，这个代码还不是要修改。说的对，接下来就是重头戏了，使用文件加载的方式加载类对象！

public class BeanFactory {// 创建文件对象private static Properties env = new Properties();// 利用静态代码块一次性的加载文件static {InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");try {env.load(inputStream);inputStream.close();} catch (IOException e) {e.printStackTrace();}}public static UserService getUserService() {UserService userService = null;try {Class clazz = Class.forName(env.getProperty("userService"));userService = (UserService) clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return userService;}
}

此时回看代码，耦合基本上就没有了，如果要添加类的话，也只需要更改文件中的类路径就行了

三、为什么使用Spring？

对于类对象，不只是单单的存在一个UserService，回看UserService方法，也是new了一个UserDao对象。肯定也是存在耦合的，这里肯定也要利用工厂类获取

此时在UserService中使用BeanFactory工厂类创建UserDao对象，并且在BeanFactory中创建对应的方法获取UserDao对象

public class BeanFactory {// 创建文件对象private static Properties env = new Properties();// 利用静态代码块一次性的加载文件static {InputStream inputStream =BeanFactory.class.getResourceAsStream("/applicationContext.properties");try {env.load(inputStream);inputStream.close();} catch (IOException e) {e.printStackTrace();}}public static UserDao getUserDao() {UserDao userDao = null;try {Class clazz = Class.forName(env.getProperty("userDao"));userDao = (UserDao) clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return userDao;}public static UserService getUserService() {UserService userService = null;try {Class clazz = Class.forName(env.getProperty("userService"));userService = (UserService) clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return userService;}
}

此时，问题又出现了，每当需要获取一个对象的时候我都要写一个方法，那这样的代码冗余不是非常高吗！此时就可以使用Object来返回对象解决此问题！

public class BeanFactory {// 创建文件private static Properties env = new Properties();// 利用静态代码块一次性的加载文件static {InputStream inputStream =BeanFactory.class.getResourceAsStream("/applicationContext.properties");try {env.load(inputStream);inputStream.close();} catch (IOException e) {e.printStackTrace();}}// 此时就利用参数获取想要创建的对象public static Object getBean(String key) {Object ret = null;try {Class clazz = Class.forName(env.getProperty(key));ret = clazz.newInstance();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (InstantiationException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}return ret;}//    public static UserService getUserService() {
//        UserService userService = null;
//        try {
//            Class clazz = Class.forName(env.getProperty("userService"));
//            userService = (UserService) clazz.newInstance();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        return userService;
//    }
//
//    public static UserDao getUserDao() {
//        UserDao userDao = null;
//        try {
//            Class clazz = Class.forName(env.getProperty("userDao"));
//            userDao = (UserDao) clazz.newInstance();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        return userDao;
//    }}

对于之前的类对象获取也需要进行相应的处理，强制类型转化即可。

至此，所有的问题都已经解决完毕了！！！从上面的过程可以发现，解耦的过程还是很复杂的，但是在Spring中已经包含了工厂的设计模式！并不需要我们去手动的写工厂类，我们只需要去使用Spring中的工厂类就可以了。Spring 框架提供了许多功能和特性，可以帮助开发人员快速构建企业应用程序。所以这也就是我们为什么要使用Spring进行项目开发的原因！

这里Spring的本质也就可以总结为：工厂！一个功能强大的工厂！至此Spring的学习正式开始