Spring基础

Posted 2022-07-01 wx62be51b466b43

Spring 基础

学完Spring有大半年了，但是一直没怎么用，复习一下。

Spring是什么？

这个问题，应该是每个人都有每个人的答案，难道仅仅说他就是一个框架？好像不是很对，因为我觉得它不仅仅是一个框架，应该说是一种架构的模式。为了解决程序之间的依赖，简化编程，快速开发具有高拓展性的工程所用的一种的模式。

一个Demo引出的问题

一个很简单的sayhello()的功能：

public class User 
    private String name;
    public void setName(String name)
        this.name=name;
    
    public void sayHello()
        System.out.println("Hello:"+name);
    

这是传入名字，输出名字:hello.
主函数测试：

public class Main 
    public static void main(String[] args) 
        User u=new User();
        u.setName("???");
        u.sayHello();
     

这样其实程序不具有可拓展性，因为不能动态的设定name。
如何动态的设定name?

配置文件解决

解决动态的修改名字这个问题，可以采用属性配置文件，新建一个name.properties:
里面填上对应的属性：

name="???"

这样可以通过每次读取配置文件获取信息：

public class Main 
    public static void main(String[] args) 
        User u=new User();
        String name="";
        Properties prop=new Properties();
        try 
            prop.load(Main.class.getClassLoader().getResourceAsStream("name.properties"));
            name=prop.getProperty("name");
        catch (Exception e)
            e.printStackTrace();
        
        u.setName(name);
        u.sayHello();
       

但是配置文件只能解决一些简单的问题，一旦涉及到类与类之间的依赖，这种配置文件就很难表示。

问题的本质

究其原因：
（1）首先程序之所以需要配置文件是因为在程序启动时，需要的参数值是不确定的，等到确定的时候，程序已经启动了，或者说在运行了。这样怎么把参数给设定一下呢？
（2）程序的依赖关系，其实指的是当前类需要调用另外一个类的方法，这个被调用的类在程序启动之前也是不确定的，或者说在程序运行期间一直是变化的，这样如何在程序变化的时候动态的修改他们的依赖关系？
这两个问题本质上是一个问题。第一种是数据依赖，第二种是类之间的依赖，本质上来说都是一种问题，为了解决这种依赖关系，大牛们提出了解决方案，并且发明了Spring框架。Spring框架能够很好的解决这个问题，如果说Spring的核心任务，我个人认为就是解耦和。

IOC

IOC(Inversion of Control).控制反转，值得是在类之间存在依赖关系时，依赖抽象非具体的类。下面通过一段简单的Spring代码来说明IOC。
Disk这个设备大家很常用，比如简单的就是U盘，还有可移动硬盘等等。电脑通过USB接口和这些外设经行交互，那么电脑对这个接口具有依赖性。显然，电脑只能依赖于一个抽象的接口，不能依赖具体的接口，很容易想到的一个问题，如果依赖U盘实现的接口，那很多其他的外设就无法识别。
下面基于这个场景来用Spring实现。
首先是抽象接口：

package com.spring.TestUSB;
// 只有两个方法，读写。
public interface Disk 
    public void read();
    public  void write();

U盘的实现：

package com.spring.TestUSB;

public class Udisk implements Disk

    @Override
    public void read() 
        System.out.println("read form Udisk");
    
    @Override
    public void write() 
        System.out.println("Wirte to Udisk");
    

可移动硬盘的实现

package com.spring.TestUSB;

public class MoveDisk implements Disk 

    @Override
    public void read() 
        System.out.println("read from MoveDisk");
    

    @Override
    public void write() 
        System.out.println("Write to MoveDisk");
    

然后是computer。computer肯定要有一个USB的对象作为自己类的成员，然后调用这个成员的方法。

package com.spring.TestUSB;
public class Computer 
    private Disk d;
    public Disk getDisk()
        return d;
    
    public void setDisk(Disk d)
        this.d=d;
    
    public void test()
        d.read();
        d.write();
    

r然后是主函数：

package com.spring.TestUSB;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main 
    public static void main(String[] args) 
       Computer com=new Computer();
       Udisk u=new Udisk();
       com.setDisk(u);
       com.test();
    

这样写对吗？显然是错的，因为这在编译期就指定了数据，是无法做到动态修改的。
所以就到了Spring最重要的配置文件了，在当前目录下新建一个beans.xml,然后配置当前所有的类：

<?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="Udisk" class="com.spring.TestUSB.Udisk" />
    <bean id="MoveDisk" class="com.spring.TestUSB.MoveDisk"/>
    
    <bean id="Computer" class="com.spring.TestUSB.Computer">
        <property name="disk" ref="MoveDisk"></property>
    </bean>
</beans>

简答的解读一下这个配置文件，首先所有的类都是bean。然后类的成员变量可以通过property指定，name指的是这个成员变量的名字，ref指的是这个变量的类型。通过这种文件，可以看出来，参数是可以动态的修改的。那么主函数怎么写呢？

package com.spring.TestUSB;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main 
   public static void main(String[] args) 
       ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
       Computer com= (Computer) applicationContext.getBean("Computer");
       com.test();
   

可以看出，这个主函数里面没有直接new Computer的对象，直接通过Application对象拿到对象。

这样做的好处

可以看到，这样做之后，参数是可以动态的修改，类直接的依赖关系也是可以通过配置文件指定。也不用自己创建对象。接下来讨论这些机制，首先参数可以动态修改，这个叫做动态注入参数，也叫做DI，依赖反转。不用自己创建类，类是由Spring创建完