Spring框架的Spring的概念，耦合、解耦，ioc，多例和单例的相关知识

Spring

Spring是什么意思？

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为 内核

Spring的体系结构是什么？

耦合

耦合是什么意思？解耦是什么意思呢？怎么解决耦合的问题呢？

耦合的意思：
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。

在软件工程中，耦合指的就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计，应使类和构件之间的耦合最小。

解耦的意思：
耦合的时候，注册驱动的时候需要new新的对象，需要依赖实现类，有依赖关系。
运行的时候才会有异常，编译的时候没有问题。

解决耦合的思路：
第一步：使用反射来创建对象，而避免使用new关键字。
第二步：通过读取配置文件来获取要创建的对象全限定类名

通过反射的方式，注册驱动，此时的好处就是我们的类中不再依赖具体的驱动类，此时依赖的驱动类只是一个字符串，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的）。还存在一个问题就是全类名还是需要修改，最好还是写好配置文件。

解决方式：
使用工厂模式来解耦，new新的对象，如果把依赖的类删掉，编译的时候不会报错，运行的时候才会报错。

代码说明：

--AccountServiceImpl.java
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
//这里依赖了AccountDaoImpl实现类
//private IAccountDao accountDao = new AccountDaoImpl();
private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");
//    private int i = 1;
    public void  saveAccount(){
        int i = 1;
        accountDao.saveAccount();
        System.out.println(i);
        i++;
    }
}


---IAccountDao.interface
/**
* 账户的持久层接口
* @Version 1.0
*/
public interface IAccountDao {
/**
* 保存账户
*/
void saveAccount();
}


---AccountDaoImpl.java
/**
* 账户的持久层实现类
* @Version 1.0
*/
public class AccountDaoImpl implements IAccountDao {
   @Override
   public void saveAccount() {
    System.out.println("保存了账户");
   }
}

多例对象和单例对象有什么区别呢？

ioc

ioc是什么含义呢？有什么作用呢？

含义：
控制反转–Inversion Of Control，把创建对象的权利交给框架；
我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

作用：
削减计算机程序的耦合(解除我们代码中的依赖关系)。

bean、java bean是什么？

maven之packaging标签有什么用？

详情参考

三层架构是什么？

详情参考

单例设计模式

设计模式可以理解成“套路”；

分为饿汉式和懒汉式

饿汉式代码：

/**
 * 单例设计模式其中一种：饿汉式单例模式(对于某一个类只能存在一个对象实例)
 * 缺点：对象的加载时间过长
 * 好处：线程安全
 */

public class 饿汉式 {
    public static void main(String[] args) {
        Bank bank0 = Bank.getInstance();
        Bank bank1 = Bank.getInstance();
        System.out.println(bank0 == bank1);//是同一个对象
    }
}

class Bank {
    //私有化构造器
    private Bank() {

    }
    //内部创建类的对象
    private static Bank instance = new Bank();

    //提供公共的静态方法，返回类的对象
    public static Bank getInstance() {
        return instance;
    }
}

懒汉式代码：

/**
 * 单例模式的懒汉模式：
 * 优点：延迟对象创建
 * 缺点：线程不安全
 * <p>
 * 单例的模式优点：只生成一个实例，减小系统开销，典型类：Runtime类
 */
public class 懒汉式 {
    public static void main(String[] args) {

        Order order0 = Order.getInstance();
        Order order1 = Order.getInstance();
        System.out.println(order0 == order1);//是同一个对象
    }

}
class Order {
    //私有化构造器
    private Order() {

    }

    //饿汉式和懒汉式的最主要的区别※
    private static Order instance = null;

    //提供公共的静态方法，返回类的对象
    //（假如两个线程访问同一个对象，第一个线程访问的时候，被阻塞了，第二个线程也new了一个对象）
    public static Order getInstance() {
        if (instance == null) {
            instance = new Order();
        }
        return instance;
    }
}

单例设计模式的一些概述：

单例的应用场景：