Spring笔记#

引入相关依赖#

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.14</version>
</dependency>

<!-- JUnit Jupiter API (测试编写) -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>

<!-- JUnit Jupiter Engine (测试执行) -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>

建立Spring配置文件#

定义一个User类

package com.spring6;
public class User {
    public void add() {
        System.out.println("add");
    }
}

xml配置文件#

按照spring要求创建配置xml文件

在配置文件中进行对于User实例的创建

id：唯一标识

class：创建对象的全路径

<?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">
    <bean id="user" class="com.spring6.User"></bean>
</beans>

进行测试#

public class TestUser {
    @Test
    public void testUserObject() {
        //加载spring配置文件，对象创建
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");

        //获取创建的对象
        User user = (User)context.getBean("user");
        System.out.println(user);//com.spring6.User@51bd8b5c

        //使用对象调用方法进行测试
        user.add();//add
    }
}

可以正常创建对象实例（反射）并且调用

OCP开闭原则#

是软件开发原则中最基本的一个原则：开闭原则

对于拓展开放，对于修改关闭

在拓展扩展系统功能的时候，没有修改以前写完的代码，就是符合OCP原则，如果修改了之前稳定的程序，修改了之前的程序，之前的程序都需要重新测试，非常麻烦

例如我们使用接口操作Dao对象的具体实现类，添加了一个新的Dao实现类，我们任然需要在调用Dao对象的程序中将原先的实例程序进行修改，违反了OCP原则

public interface UserDao {
    void deleteUser();
}

public class UserDaoImplForMySQL implements UserDao {
    @Override
    public void deleteUser() {
        System.out.println("数据操作层");
        System.out.println("Delete User");
    }
}

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImplForMySQL();
    //这里需要修改
    //private UserDao userDao = new UserDaoImplForNoSQL();
    @Override
    public void deleteRequest() {
        System.out.println("业务层");
        userDao.deleteUser();
    }
}

DIP依赖倒置原则#

定义：上层不再调用下层

核心：面向抽象编程，接口编程，不面向具体编程

视图层调用了服务层，服务层调用了数据操作层

上层的层级因为需要调用下层的对象以及方法，依赖于下层，违背了依赖倒置原则

上层Service

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImplForMySQL();
    //这里使用了具体的下层方法 UserDaoImplForMySQL 存在依赖
    @Override
    public void deleteRequest() {
        System.out.println("业务层");
        userDao.deleteUser();
    }
}

下层Dao

public class UserDaoImplForMySQL implements UserDao {
    @Override
    public void deleteUser() {
        System.out.println("数据操作层");
        System.out.println("Delete User");
    }
}

我们需要解决以上的两个问题，我们需要删除用new创建的对象，将对象的创建维护的权利交付出去，这也就是我们所谓的控制反转

IoC控制反转#

反转的是：不在程序中采用硬编码的方式new对象，不在程序中采用硬编码的方式维护对象的关系

public class UserAction {
    private UserService userService;//不再创建对象
    @Test
    public void deleteAction() {
        System.out.println("显示层");
        userService.deleteRequest();
    }
}

public class UserServiceImpl implements UserService {
    private UserDao userDao;//不再创建对象
    @Override
    public void deleteRequest() {
        System.out.println("业务层");
        userDao.deleteUser();
    }
}

这时候代码不能运行（因为对象间的关系没有建立，会发生空指针异常），我们还需要把创建的对象过程和对象间的关系交给Spring进行管理（依赖注入Dependency Injection 是控制反转的实现）

依赖是两个对象之间的关系，而注入是一种手段可以产生对象关系

可以通过构造方法注入（通过构造方法设置接口值），或者Set方法注入（通过Set方法设置接口值）